BOAST 1.2.2 → 1.3.0

data/lib/BOAST/Language/Transitions.rb

@@ -13,34 +13,34 @@ module BOAST
       t = ops[:default]
       return [t,operator] if t
       raise "Unresolvable transition!"
-     end
+    end
 
-     def set_transition(type1, type2, operator, return_type)
-       @@transitions[[type1,type2]][operator] = return_type
-     end
+    def set_transition(type1, type2, operator, return_type)
+      @@transitions[[type1,type2]][operator] = return_type
+    end
 
-     def transition(var1, var2, operator)
-       signed = false
-       size = nil
-       vector_length = 1
-       t1 = var1.type.class
-       t2 = var2.type.class
-       t1 = var1.type.name if t1 == CustomType
-       t2 = var2.type.name if t2 == CustomType
-       return_type, operator = get_transition(t1, t2, operator)
-       #STDERR.puts "#{return_type} : #{var1.type.class} #{operator} #{var2.type.class}"
-       if t1 == return_type and t2 == return_type then
-         signed = (signed or var1.type.signed)
-         signed = (signed or var2.type.signed)
-         size = [var1.type.size, var2.type.size].max
-         vector_length = [var1.type.vector_length, var2.type.vector_length].max
-         return [Variable::new("dummy", return_type, :size => size, :signed => signed, :vector_length => vector_length), operator]
-       elsif var1.type.class == return_type then
-         return [var1, operator]
-       else # var2.type.class == return_type then
-         return [var2, operator]
-       end
-     end
+    def transition(var1, var2, operator)
+      signed = false
+      size = nil
+      vector_length = 1
+      t1 = var1.type.class
+      t2 = var2.type.class
+      t1 = var1.type.name if t1 == CustomType
+      t2 = var2.type.name if t2 == CustomType
+      return_type, operator = get_transition(t1, t2, operator)
+      #STDERR.puts "#{return_type} : #{var1.type.class} #{operator} #{var2.type.class}"
+      if t1 == return_type and t2 == return_type then
+        signed = (signed or var1.type.signed)
+        signed = (signed or var2.type.signed)
+        size = [var1.type.size, var2.type.size].max
+        vector_length = [var1.type.vector_length, var2.type.vector_length].max
+        return [Variable::new("dummy", return_type, :size => size, :signed => signed, :vector_length => vector_length), operator]
+      elsif var1.type.class == return_type then
+        return [var1, operator]
+      else # var2.type.class == return_type then
+        return [var2, operator]
+      end
+    end
 
   end
 

data/lib/BOAST/Language/Variable.rb

@@ -1,5 +1,6 @@
 module BOAST
 
+  # @!parse module Functors; functorize Dimension; end
   class Dimension
     include PrivateStateAccessor
     include Inspectable
@@ -9,10 +10,19 @@ module BOAST
     attr_reader :val2
     attr_reader :size
 
+    # Creates a new {Dimension}.
+    # @overload initialize()
+    #   Creates a {Dimension} of unknown {#size}, used to declare an array of unknown size.
+    # @overload initialize( size )
+    #   Creates a {Dimension} of size *size*, {#start} is computed at evaluation as {BOAST.get_array_start}.
+    #   @param [Object] size can be an integer or a {Variable} or {Expression}
+    # @overload initialize( lower, upper )
+    #   Creates a {Dimension} with a lower and upper bound. {#size} is computed as 'upper - lower + 1' and can be an {Expression}
+    #   @param [Object] lower bound of the {Dimension}
+    #   @param [Object] upper bound of the {Dimension}
     def initialize(v1=nil,v2=nil)
       if v1 then
         if v2 then
-          #@size = Expression::new(Substraction, v2, v1) + 1
           begin
             @size = v2-v1+1
           rescue
@@ -28,6 +38,7 @@ module BOAST
       @val2 = v2
     end
 
+    # Returns a {String} representation of the {Dimension}
     def to_s
       if lang == FORTRAN and @val2 then
         return "#{@val1}:#{@val2}"
@@ -40,6 +51,7 @@ module BOAST
       end 
     end
 
+    # Returns the start of the {Dimension} as given at initialization or as computed {BOAST.get_array_start}.
     def start
       if @val2 then
         return @val1
@@ -48,6 +60,7 @@ module BOAST
       end
     end
 
+    # Returns the end of the {Dimension} if the size is known.
     def finish
       if @val2 then
         return @val2
@@ -72,6 +85,10 @@ module BOAST
 
   end
 
+  module Functors
+    alias Dim Dimension
+  end
+
   class ConstArray < Array
     include PrivateStateAccessor
     include Inspectable
@@ -88,8 +105,10 @@ module BOAST
       return to_s_c if [C, CL, CUDA].include?( lang )
     end
 
+    private
+
     def to_s_fortran
-      arr = self.flatten
+      arr = flatten
       s = ""
       return s if arr.first.nil?
       s += "reshape(" if @shape
@@ -106,7 +125,7 @@ module BOAST
     end
 
     def to_s_c
-      arr = self.flatten
+      arr = flatten
       s = ""
       return s if arr.first.nil?
       s += "{\n"
@@ -118,8 +137,10 @@ module BOAST
       }
       s += "}"
     end
+
   end
 
+  # @!parse module Functors; functorize Variable; end
   class Variable
     include PrivateStateAccessor
     include Arithmetic
@@ -137,7 +158,7 @@ module BOAST
         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 self.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)
         else
           return orig_method_missing(m, *a, &b)
         end
@@ -210,21 +231,25 @@ module BOAST
       !!@deferred_shape
     end
 
-    def initialize(name,type,hash={})
+    # Creates a new {Variable}
+    # @param [#to_s] name
+    # @param [DataType] type
+    # @param [Hash] properties a set of named properties.
+    def initialize(name, type, properties={})
       @name = name.to_s
-      @direction = hash[:direction] ? hash[:direction] : hash[:dir]
-      @constant = hash[:constant] ? hash[:constant]  : hash[:const]
-      @dimension = hash[:dimension] ? hash[:dimension] : hash[:dim]
-      @local = hash[:local] ? hash[:local] : hash[:shared]
-      @texture = hash[:texture]
-      @allocate = hash[:allocate]
-      @restrict = hash[:restrict]
-      @alignment = hash[:align]
-      @deferred_shape = hash[:deferred_shape]
-      @optional = hash[:optional]
+      @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]
+      @texture = properties[:texture]
+      @allocate = properties[:allocate]
+      @restrict = properties[:restrict]
+      @alignment = properties[:align]
+      @deferred_shape = properties[:deferred_shape]
+      @optional = properties[:optional]
       @force_replace_constant = false
-      if not hash[:replace_constant].nil? then
-        @replace_constant = hash[:replace_constant]
+      if not properties[:replace_constant].nil? then
+        @replace_constant = properties[:replace_constant]
       else
         @replace_constant = true
       end
@@ -233,8 +258,8 @@ module BOAST
       else
         @sampler = nil
       end
-      @type = type::new(hash)
-      @options = hash
+      @type = type::new(properties)
+      @properties = properties
       if (@direction == :out or @direction == :inout) and not dimension? then
         @scalar_output = true
       else
@@ -243,10 +268,10 @@ module BOAST
       @dimension = [@dimension].flatten if dimension?
     end
 
-    def copy(name=nil,options={})
+    def copy(name=nil,properties={})
       name = @name if not name
-      h = @options.clone
-      options.each { |k,v|
+      h = @properties.clone
+      properties.each { |k,v|
         h[k] = v
       }
       return Variable::new(name, @type.class, h)
@@ -257,9 +282,9 @@ module BOAST
       return self
     end
 
-    def self.from_type(name, type, options={})
+    def self.from_type(name, type, properties={})
       hash = type.to_hash
-      options.each { |k,v|
+      properties.each { |k,v|
         hash[k] = v
       }
       hash[:direction] = nil
@@ -304,13 +329,6 @@ module BOAST
       return Index::new(self,*args)
     end
  
-    def finalize
-       s = ""
-       s += ";" if [C, CL, CUDA].include?( lang )
-       s+="\n"
-       return s
-    end
-
     def boast_header(lang=C)
       return decl_texture_s if texture?
       s = ""
@@ -345,12 +363,39 @@ module BOAST
       return decl_c if [C, CL, CUDA].include?( lang )
     end
 
+    def align
+      if dimension? then
+        if align? or default_align > 1 then
+          a = ( align? ? alignment : 1 )
+          a = ( a >= default_align ? a : default_align )
+          return align_c(a) if lang == C
+          return align_fortran(a) if lang == FORTRAN
+        end
+      end
+      return nil
+    end
+
+    def alloc( dims = nil, align = get_address_size )
+      @dimension = [dims].flatten if dims
+      dims = @dimension
+      raise "Cannot allocate array with unknown dimension!" unless dims
+      return alloc_fortran(dims) if lang == FORTRAN
+      return alloc_c(dims, align) if lang == C
+    end
+
+    def dealloc
+      return dealloc_fortran if lang == FORTRAN
+      return dealloc_c if lang == C
+    end
+
+    private
+
     def __const?
       return !!( constant? or @direction == :in )
     end
 
     def __global?
-      return !!( lang == CL and @direction and dimension? and not (@options[:register] or @options[:private] or local?) )
+      return !!( lang == CL and @direction and dimension? and not (@properties[:register] or @properties[:private] or local?) )
     end
 
     def __local?
@@ -468,18 +513,6 @@ module BOAST
       return Pragma::new("DIR", "ASSUME_ALIGNED", "#{@name}: #{a}")
     end
 
-    def align
-      if dimension? then
-        if align? or default_align > 1 then
-          a = ( align? ? alignment : 1 )
-          a = ( a >= default_align ? a : default_align )
-          return align_c(a) if lang == C
-          return align_fortran(a) if lang == FORTRAN
-        end
-      end
-      return nil
-    end
-
     def alloc_fortran( dims = nil )
       return FuncCall::new(:allocate, FuncCall(name, * dims ) )
     end
@@ -489,20 +522,12 @@ module BOAST
       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, self.address, align, FuncCall::new(:sizeof, @type.decl) * d)
+        return FuncCall::new(:posix_memalign, address, align, FuncCall::new(:sizeof, @type.decl) * d)
       else
         return self === FuncCall::new(:malloc, FuncCall::new(:sizeof, @type.decl) * d).cast(self)
       end
     end
 
-    def alloc( dims = nil, align = get_address_size )
-      @dimension = [dims].flatten if dims
-      dims = @dimension
-      raise "Cannot allocate array with unknown dimension!" unless dims
-      return alloc_fortran(dims) if lang == FORTRAN
-      return alloc_c(dims, align) if lang == C
-    end
-
     def dealloc_fortran
       return FuncCall::new(:deallocate, self)
     end
@@ -511,11 +536,6 @@ module BOAST
       return FuncCall::new(:free, self)
     end
 
-    def dealloc
-      return dealloc_fortran if lang == FORTRAN
-      return dealloc_c if lang == C
-    end
-
     def decl_fortran
       s = ""
       s += indent
@@ -555,6 +575,17 @@ module BOAST
       return self
     end
 
+    def finalize
+       s = ""
+       s += ";" if [C, CL, CUDA].include?( lang )
+       s+="\n"
+       return s
+    end
+
+  end
+
+  module Functors
+    alias Var Variable
   end
 
 end

data/lib/BOAST/Language/While.rb

@@ -1,5 +1,6 @@
 module BOAST
 
+  # @!parse module Functors; functorize While; end
   class While < ControlStructure
     include Annotation
     ANNOTATIONS = [ :condition ]
@@ -21,6 +22,8 @@ module BOAST
                :end => '"end do"' }
     end
 
+    private :get_c_strings, :get_fortran_strings
+
     alias get_cl_strings get_c_strings
     alias get_cuda_strings get_c_strings
 

data/lib/BOAST/Runtime/AffinityProbe.rb

@@ -0,0 +1,65 @@
+module BOAST
+
+  # @private
+  module AffinityProbe
+    extend PrivateStateAccessor
+
+    module_function
+
+    def header
+      get_output.puts "#ifndef _GNU_SOURCE"
+      get_output.puts "#define _GNU_SOURCE"
+      get_output.puts "#endif"
+      get_output.puts "#include <sched.h>"
+    end
+
+    def decl
+      get_output.puts "  cpu_set_t _boast_affinity_mask_old;"
+      get_output.puts "  int _boast_affinity_set = 0;"
+    end
+
+    def configure
+      get_output.print <<EOF
+  if( _boast_rb_opts != Qnil ) {
+    VALUE _boast_affinity_rb_ptr = Qnil;
+
+    _boast_affinity_rb_ptr = rb_hash_aref(_boast_rb_opts, ID2SYM(rb_intern("cpu_affinity")));
+
+    if( _boast_affinity_rb_ptr != Qnil ) {
+      cpu_set_t _boast_affinity_mask;
+      int _boast_affinity_counter;
+      int _boast_affinity_cpu_number;
+
+      if( TYPE(_boast_affinity_rb_ptr) != T_ARRAY )
+        rb_raise(rb_eArgError, "Option :cpu_affinity should be an array!");
+      CPU_ZERO(&_boast_affinity_mask);
+      _boast_affinity_cpu_number = RARRAY_LEN(_boast_affinity_rb_ptr);
+      for( _boast_affinity_counter = 0; _boast_affinity_counter < _boast_affinity_cpu_number; _boast_affinity_counter++ )
+        CPU_SET(FIX2INT(rb_ary_entry(_boast_affinity_rb_ptr,_boast_affinity_counter)), &_boast_affinity_mask);
+      sched_getaffinity(getpid(), sizeof(_boast_affinity_mask_old), &_boast_affinity_mask_old);
+      if( sched_setaffinity(getpid(), sizeof(_boast_affinity_mask), &_boast_affinity_mask) != 0)
+        rb_raise(rb_eArgError, "Invalid affinity list provided!");
+      _boast_affinity_set = 1;
+    }
+  }
+EOF
+    end
+
+    def start
+    end
+
+    def stop
+    end
+
+    def compute
+      get_output.print <<EOF
+  if ( _boast_affinity_set == 1 ) {
+    sched_setaffinity(getpid(), sizeof(_boast_affinity_mask_old), &_boast_affinity_mask_old);
+    _boast_affinity_set = 0;
+  }
+EOF
+    end
+
+  end
+
+end

data/lib/BOAST/Runtime/CKernel.rb

@@ -23,7 +23,13 @@ module BOAST
     attr_accessor :architecture
     attr_accessor :kernels
     attr_accessor :cost_function
-    
+
+    # Creates a new CKernel object. BOAST output is redirected to the CKernel. If the chain_code state is set the current BOAST output, as returned by {BOAST.get_output}, is used.
+    # @param [Hash] options contains named options
+    # @option options [StringIO] :code specify a StringIO to use rather than create a new one.
+    # @option options [Array] :kernels list of kernels this kernel depends on. The kernels will be linked at build time.
+    # @option options [Integer] :lang specify the language to use. Default is current language state as returned by {BOAST.get_lang}.
+    # @option options [Integer] :architecture specify the architecture to use. Default is the current BOAST architecture as returned by {BOAST.get_architecture}.
     def initialize(options={})
       if options[:code] then
         @code = options[:code]
@@ -50,6 +56,7 @@ module BOAST
         @architecture = get_architecture
       end
       @probes = [TimerProbe, PAPIProbe]
+      @probes.push AffinityProbe unless OS.mac?
 
       case @lang
       when CL
@@ -71,11 +78,13 @@ module BOAST
       end
     end
 
+    # @deprecated
     def print
       @code.rewind
       puts @code.read
     end
 
+    # @return [String] source code of the kernel
     def to_s
       if @lang == FORTRAN then
         return line_limited_source
@@ -85,6 +94,7 @@ module BOAST
       end
     end
 
+    # @private
     def method_missing(meth, *args, &block)
      if meth.to_s == "run" then
        build
@@ -94,8 +104,41 @@ module BOAST
      end
     end
 
+    # If a cost function is provided returns the cost of running the function on the provided arguments.
     def cost(*args)
       @cost_function.call(*args)
     end
+
+    # @!method build( options = {} )
+    # Builds the computing kernel.
+    # @param [Hash] options contains build time options. Usual compiling flags are supported. Default values can be overriden in $XDG_CONFIG_HOME/.config/BOAST/compiler_options or $HOME/.config/BOAST/compiler_options. The same flags can be set as environment variables. Flags given here override environment variable ones.
+    # @option options [String] :CC C compiler
+    # @option options [String] :CFLAGS C compiler flags
+    # @option options [String] :FC Fortran compiler
+    # @option options [String] :FCFLAGS Fortran compiler flags
+    # @option options [String] :CXX C++ compiler
+    # @option options [String] :CXXFLAGS C++ compiler flags
+    # @option options [String] :LD linker
+    # @option options [String] :LDFLAGS linker flags
+    # @option options [Boolean] :OPENMP activate OpenMP support. Correct flag should be set for your compiler in $XDG_CONFIG_HOME/.config/BOAST/openmp_flags or $HOME/.config/BOAST/openmp_flags.
+    # @option options [String] :NVCC cuda compiler
+    # @option options [String] :NVCCFLAGS cuda compiler flags
+    # @option options [String] :CLFLAGS opencl compiation flags
+    # @option options [String] :CLVENDOR restrict selected OpenCL platforms to the ones which vendor match the option
+    # @option options [String] :CLPLATFORM restrict selected OpenCL platforms to the ones which name match the option
+    # @option options [String] :CLDEVICE restrict selected OpenCL devices to the ones which mame match the option or use the provided OpenCL::Device
+    # @option options [String] :CLCONTEXT use the devices in the given OpenCL::Context
+    # @option options [String] :CLDEVICETYPE restrict selected OpenCL devices to the corresponding types
+
+    # @!method run( *args, options = {} )
+    # Runs the computing kernel using the given arguments.
+    # @param args the arguments corresponding to the list of parameters of the #procedure attribute
+    # @param [Hash] options contains runtime options.
+    # @option options [Array] :global_work_size only considered for CUDA and OpenCL kernels. See corresponding OpenCL documentation
+    # @option options [Array] :local_work_size only considered for CUDA and OpenCL kernels. See corresponding OpenCL documentation
+    # @option options [Array] :block_number only considered for CUDA and OpenCL kernels. See corresponding CUDA documentation
+    # @option options [Array] :block_size only considered for CUDA and OpenCL kernels. See corresponding CUDA documentation
+    # @option options [Array] :PAPI list of PAPI counters to monitor. ( ex: ['PAPI_L1_DCM', 'PAPI_L2_DCM'], see PAPI documentation.
+    # @return [Hash] contains at least the *:duration* entry which is the runtime of the kernel in seconds. If the kernel is a function then the *:return* field will contain the returned value. For :inout or :out scalars the *:reference_return* field will be a Hash with each parameter name associated to the corresponding value. If *:PAPI* options was given will contain a *:PAPI* entry with the corresponding counters value.
   end
 end