BOAST 2.0.2 → 2.1.0

data/lib/BOAST/Language/Slice.rb

@@ -63,7 +63,7 @@ module BOAST
           else
             @first = Expression::new(Addition, s.first, @first )
           end
-          if not scalar? then
+          unless scalar? then
             if s.step then
               if @step then
                 @step = Expression::new(Multiplication, @step, s.step)
@@ -92,7 +92,7 @@ module BOAST
     attr_accessor :alignment
 
     def initialize(source, *slices)
-      raise "Cannot slice a non array Variable!" if not source.dimension?
+      raise "Cannot slice a non array Variable!" unless source.dimension?
       raise "Invalid slice!" if slices.length != source.dimension.length
       @source = source
       @slices = slices.collect{ |s| SliceItem::new(s) }
@@ -105,7 +105,7 @@ module BOAST
     def dimension
       dims = []
       slices.each_with_index { |slice, i|
-        if not slice.scalar? then
+        unless slice.scalar? then
           if slice.all? then
             if source.dimension[i].size then
               dims.push Dimension::new( source.dimension[i].size )
@@ -127,15 +127,15 @@ module BOAST
 
     def pr
       s=""
-      s += indent
-      s += to_s
-      s += ";" if [C, CL, CUDA].include?( lang )
+      s << indent
+      s << to_s
+      s << ";" if [C, CL, CUDA].include?( lang )
       output.puts s
       return self
     end
 
     def align?
-      return !!@alignment
+      return @alignment
     end
 
     def set_align(align)
@@ -162,7 +162,7 @@ module BOAST
       }
       new_args = []
       slices.each_with_index { |s, i|
-        if not s.scalar?
+        unless s.scalar?
           raise "Invalid slice!" if args.length == 0
           new_arg = SliceItem::new(args.shift)
           new_arg.recurse!(s, @source.dimension[i])
@@ -188,9 +188,9 @@ module BOAST
         else
           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
+          unless 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
@@ -205,9 +205,9 @@ module BOAST
           ":"
         else
           s = "#{slice.first}"
-          if not slice.scalar? then
-            s += ":#{slice.last}"
-            s += ":#{slice.step}" if slice.step
+          unless slice.scalar? then
+            s << ":#{slice.last}"
+            s << ":#{slice.step}" if slice.step
           end
           s
         end

data/lib/BOAST/Language/State.rb

@@ -64,7 +64,7 @@ EOF
   module_function
 
   def #{state}?
-    !!@@#{state}
+    @@#{state}
   end
 EOF
     eval s

data/lib/BOAST/Language/Transitions.rb

@@ -7,7 +7,7 @@ module BOAST
     def get_transition(type1, type2, operator)
       #STDERR.puts @@transitions.inspect
       ops = @@transitions[[type1,type2]]
-      raise "Types #{[type1,type2]} have no relation!" if not ops
+      raise "Types #{[type1,type2]} have no relation!" unless ops
       t = ops[operator]
       return [t,operator] if t
       t = ops[:default]

data/lib/BOAST/Language/Variable.rb

@@ -48,7 +48,7 @@ module BOAST
         return "#{get_array_start}:#{@size-(1+get_array_start)}"
       else
         return @size.to_s
-      end 
+      end
     end
 
     # Returns the start of the {Dimension} as given at initialization or as computed {BOAST.get_array_start}.
@@ -111,16 +111,16 @@ module BOAST
       arr = flatten
       s = ""
       return s if arr.first.nil?
-      s += "reshape(" if @shape
-      s += "(/ &\n"
-      s += arr.first.to_s
-      s += @type.suffix if @type
+      s << "reshape(" if @shape
+      s << "(/ &\n"
+      s << arr.first.to_s
+      s << @type.suffix if @type
       arr[1..-1].each { |v|
-        s += ", &\n"+v.to_s
-        s += @type.suffix if @type
+        s << ", &\n"+v.to_s
+        s << @type.suffix if @type
       }
-      s += " /)"
-      s += ", shape(#{@shape}))" if @shape
+      s << " /)"
+      s << ", shape(#{@shape}))" if @shape
       return s
     end
 
@@ -128,14 +128,14 @@ module BOAST
       arr = flatten
       s = ""
       return s if arr.first.nil?
-      s += "{\n"
-      s += arr.first.to_s
-      s += @type.suffix if @type 
+      s << "{\n"
+      s << arr.first.to_s
+      s << @type.suffix if @type
       arr[1..-1].each { |v|
-        s += ",\n"+v.to_s
-        s += @type.suffix if @type
+        s << ",\n"+v.to_s
+        s << @type.suffix if @type
       }
-      s += "}"
+      s << "}"
     end
 
   end
@@ -150,7 +150,7 @@ module BOAST
     ANNOTATIONS = [ :name, :type, :dimension ]
 
     def method_missing(m, *a, &b)
-      if @type.methods.include?(:members) and @type.members[m.to_s] then
+      if @type.kind_of?(CStruct) and @type.members[m.to_s] then
         return struct_reference(type.members[m.to_s])
       elsif __vector? and m.to_s[0] == 's' and lang != CUDA then
         required_set = m.to_s[1..-1].chars.to_a
@@ -264,17 +264,10 @@ module BOAST
     # @option properties [Boolean] :optional for Fortran interface generation mainly see Fortran documentation
     def initialize(name, type, properties={})
       @name = name.to_s
-      @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
+      @direction = properties[:direction] or @direction = properties[:dir]
+      @constant = properties[:constant] or @constant = properties[:const]
+      @dimension = properties[:dimension] or @dimension = properties[:dim]
+      @local = properties[:local] or @local = properties[:shared]
 
       @texture = properties[:texture]
       @allocate = properties[:allocate]
@@ -304,7 +297,7 @@ module BOAST
     end
 
     def copy(name=nil,properties={})
-      name = @name if not name
+      name = @name unless name
       h = @properties.clone
       properties.each { |k,v|
         h[k] = v
@@ -326,7 +319,7 @@ module BOAST
       hash[:dir] = nil
       return Variable::new(name, type.class, hash)
     end
-  
+
     def to_s
       if force_replace_constant? or ( ( replace_constant? or replace_constants? ) and constant? and not dimension? ) then
         s = @constant.to_s + @type.suffix
@@ -350,12 +343,12 @@ module BOAST
       return copy("*(#{name})", :dimension => nil, :dim => nil, :direction => nil, :dir => nil) if [C, CL, CUDA].include?( lang )
       return Index::new(self, *(@dimension.collect { |d| d.start } ) ) if lang == FORTRAN
     end
-   
+
     def struct_reference(x)
       return x.copy(name+"."+x.name) if [C, CL, CUDA].include?( lang )
       return x.copy(name+"%"+x.name) if lang == FORTRAN
     end
- 
+
     def inc
       return Expression::new("++",self,nil)
     end
@@ -378,23 +371,23 @@ module BOAST
         return Index::new(self, *args)
       end
     end
- 
+
     def boast_header(lang=C)
       return decl_texture_s if texture?
       s = ""
-      s += "const " if constant? or @direction == :in
-      s += @type.decl
+      s << "const " if constant? or @direction == :in
+      s << @type.decl
       if dimension? then
-        s += " *" unless (use_vla? and lang != FORTRAN)
+        s << " *" unless (use_vla? and lang != FORTRAN)
       end
       if not dimension? and ( lang == FORTRAN or @direction == :out or @direction == :inout or @reference ) then
-        s += " *"
+        s << " *"
       end
-      s += " #{@name}"
+      s << " #{@name}"
       if dimension? and use_vla? and lang != FORTRAN  then
-        s += "["
-        s += @dimension.reverse.collect(&:to_s).join("][")
-        s += "]"
+        s << "["
+        s << @dimension.reverse.collect(&:to_s).join("][")
+        s << "]"
       end
       return s
     end
@@ -491,47 +484,47 @@ module BOAST
     def decl_c_s(device = false)
       return decl_texture_s if texture?
       s = ""
-      s += "const " if __const?
-      s += "__global " if __global?
-      s += "__local " if __local?
-      s += "__shared__ " if __shared?(device)
-      s += @type.decl
+      s << "const " if __const?
+      s << "__global " if __global?
+      s << "__local " if __local?
+      s << "__shared__ " if __shared?(device)
+      s << @type.decl
       if __vla_array? then
-        s += " #{@name}["
-        s += "__restrict__ " if __restrict?
-        s += @dimension.reverse.collect(&:to_s).join("][")
-        s += "]"
+        s << " #{@name}["
+        s << "__restrict__ " if __restrict?
+        s << @dimension.reverse.collect(&:to_s).join("][")
+        s << "]"
       else
-        s += " *" if __pointer?(device)
+        s << " *" if __pointer?(device)
         if __pointer_array?(device) and __restrict? then
           if lang == CL
-            s += " restrict"
+            s << " restrict"
           else
-            s += " __restrict__" unless use_vla?
+            s << " __restrict__" unless use_vla?
           end
         end
-        s += " #{@name}"
+        s << " #{@name}"
         if dimension? and constant? then
-          s += "[]"
+          s << "[]"
         end
         if __dimension?(device) then
-          s +="[("
-          s += @dimension.collect(&:to_s).reverse.join(")*(")
-          s +=")]"
-        end 
+          s << "[("
+          s << @dimension.collect(&:to_s).reverse.join(")*(")
+          s << ")]"
+        end
       end
       if __align? and lang != CUDA then
         a = ( align? ? alignment : 1 )
         a = ( a >= default_align ? a : default_align )
-        s+= " __attribute((aligned(#{a})))"
+        s << " __attribute((aligned(#{a})))"
       end
-      s += " = #{@constant}" if constant?
+      s << " = #{@constant}" if constant?
       return s
     end
 
     def decl_texture_s
-      raise LanguageError, "Unsupported language #{lang} for texture!" if not [CL, CUDA].include?( lang )
-      raise "Write is unsupported for textures!" if not (constant? or @direction == :in)
+      raise LanguageError, "Unsupported language #{lang} for texture!" unless [CL, CUDA].include?( lang )
+      raise "Write is unsupported for textures!" unless (constant? or @direction == :in)
       dim_number = 1
       if dimension? then
         dim_number == @dimension.size
@@ -539,24 +532,24 @@ module BOAST
       raise "Unsupported number of dimension: #{dim_number}!" if dim_number > 3
       s = ""
       if lang == CL then
-        s += "__read_only "
+        s << "__read_only "
         if dim_number < 3 then
-          s += "image2d_t " #from OCL 1.2+ image1d_t is defined
+          s << "image2d_t " #from OCL 1.2+ image1d_t is defined
         else
-          s += "image3d_t "
+          s << "image3d_t "
         end
       else
-        s += "texture<#{@type.decl}, cudaTextureType#{dim_number}D, cudaReadModeElementType> "
+        s << "texture<#{@type.decl}, cudaTextureType#{dim_number}D, cudaReadModeElementType> "
       end
-      s += @name
+      s << @name
       return s
     end
 
     def decl_c
       s = ""
-      s += indent
-      s += decl_c_s
-      s += finalize
+      s << indent
+      s << decl_c_s
+      s << finalize
       output.print s
       return self
     end
@@ -595,42 +588,42 @@ module BOAST
 
     def decl_fortran
       s = ""
-      s += indent
-      s += @type.decl
-      s += ", intent(#{@direction})" if @direction
-      s += ", optional" if optional?
-      s += ", allocatable" if allocate? and @allocate == :heap
-      s += ", parameter" if constant?
+      s << indent
+      s << @type.decl
+      s << ", intent(#{@direction})" if @direction
+      s << ", optional" if optional?
+      s << ", allocatable" if allocate? and @allocate == :heap
+      s << ", parameter" if constant?
       if dimension? or __vector? then
-        s += ", dimension("
+        s << ", dimension("
         if __vector? then
-          s += "#{@type.vector_length}"
-          s += ", " if dimension?
+          s << "#{@type.vector_length}"
+          s << ", " if dimension?
         end
-        s += @dimension.collect { |d|
+        s << @dimension.collect { |d|
           if deferred_shape? or ( allocate? and @allocate == :heap )
             ":"
           else
             d.to_s
           end
         }.join(", ") if dimension?
-        s += ")"
+        s << ")"
       end
-      s += " :: #{@name}"
+      s << " :: #{@name}"
       if constant? then
         @constant.shape = self if dimension? and @constant.kind_of?(ConstArray)
-        s += " = #{@constant}"
-        s += @type.suffix if not dimension? and @type
+        s << " = #{@constant}"
+        s << @type.suffix if not dimension? and @type
       end
-      s += finalize
+      s << finalize
       output.print s
       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 = ""
-        s += indent
-        s += "!DIR$ ATTRIBUTES ALIGN: #{a}:: #{name}"
-        s += finalize
+        s << indent
+        s << "!DIR$ ATTRIBUTES ALIGN: #{a}:: #{name}"
+        s << finalize
         output.print s
       end
       return self
@@ -638,8 +631,8 @@ module BOAST
 
     def finalize
        s = ""
-       s += ";" if [C, CL, CUDA].include?( lang )
-       s+="\n"
+       s << ";" if [C, CL, CUDA].include?( lang )
+       s << "\n"
        return s
     end
 

data/lib/BOAST/Language/While.rb

@@ -43,8 +43,8 @@ module BOAST
     # @return [self]
     def open
       s=""
-      s += indent
-      s += to_s
+      s << indent
+      s << to_s
       output.puts s
       increment_indent_level
       return self
@@ -71,8 +71,8 @@ module BOAST
     def close
       decrement_indent_level      
       s = ""
-      s += indent
-      s += end_string
+      s << indent
+      s << end_string
       output.puts s
       return self
     end

data/lib/BOAST/Optimization/Optimization.rb

@@ -42,6 +42,23 @@ module BOAST
       else
         @parameters = parameters
       end
+      if @checkers then
+        @checkers.each { |checker| eval checker }
+      end
+      if @rules then
+        s = <<EOF
+  def rules_checker(#{HASH_NAME})
+    return ( (#{@rules.join(") and (")}) )
+  end
+EOF
+      else
+s = <<EOF
+  def rules_checker(#{HASH_NAME})
+    return true
+  end
+EOF
+      end
+      eval s
     end
 
     # Add to the parameters of the rules the name of the hash variable
@@ -59,16 +76,11 @@ module BOAST
     # Remove all points that do not meet ALL the rules.
     def remove_unfeasible (points = [])
       if @rules then
-        if @checkers
-          @checkers.each { |checker| eval checker }
-        end
-        s = <<EOF
-      points.reject!{ |#{HASH_NAME}|
-        not @rules.all?{ |r| eval r }
-      }
-EOF
-        eval s
+        points.select!{ |pt|
+          rules_checker(pt)
+        }
       end
+      return points
     end
 
     def to_h
@@ -184,46 +196,58 @@ EOF
       @seed = options[:seed]
     end
 
-    def points
-      params2 = @search_space.parameters.dup
-      param = params2.shift
-      
-      pts = param.values.collect { |val| {param.name => val} }
-      if params2.size == 0 then
-        pts4 = pts 
-      else
-        optim2 = BruteForceOptimizer::new(OptimizationSpace::new(*params2))
-        pts3=[]
-        pts.each{ |p1|
-          optim2.each { |p2|
-            pts3.push(p1.dup.update(p2))
-          }
-        }
-        pts4 = pts3
-      end
-      @search_space.remove_unfeasible pts4
-      return pts4
+#    def points
+#      array = @search_space.parameters.collect { |p| p.values.collect { |val| [p.name,val] } }
+#      pts = array[0]
+#      pts = pts.product(*array[1..-1]) if array.length > 1
+#      pts = pts.collect { |a| Hash[ *a.flatten ] }
+#      return pts.select{ |pt| @search_space.rules_checker(pt) }
+#    end
+
+    def to_a
+      return each.to_a
     end
 
-    def each(&block)
-      return self.points.each(&block)
+    alias points to_a
+
+    def each
+      array = @search_space.parameters.collect { |p| [p.name,p.values.to_a] }
+      lazy_block = lambda { |rank, data|
+        array[rank][1].each { |d|
+          data[array[rank][0]] = d
+          if rank == array.length - 1 then
+            yield data.dup if @search_space.rules_checker(data)
+          else
+            lazy_block.call(rank+1, data)
+          end
+        }
+      }
+      if block_given? then
+        lazy_block.call(0, {})
+        return self
+      else
+        return to_enum(:each)
+      end
     end
 
-    def each_random(&block)
-      return self.points.shuffle.each(&block)
+    def each_random( &block)
+      self.points.shuffle.each(&block)
+      return self if block_given?
     end
 
     def optimize(&block)
       @experiments = 0
       @log = {}
       best = [nil, Float::INFINITY]
-      pts = points
+      e = each
       
-      (@seed ? pts.shuffle!(random: Random.new(@seed)) : pts.shuffle!) if @randomize
-
-      pts = pts.slice(@checkpoint,@checkpoint_size) if @checkpoint_size
+      if @randomize then
+        e = e.to_a
+        (@seed ? e.shuffle!(random: Random.new(@seed)) : e.shuffle!)
+      end
+      e = e.drop(@checkpoint).take(@checkpoint_size) if @checkpoint_size
 
-      pts.each { |config|
+      e.each { |config|
         @experiments += 1
         metric = block.call(config)
         @log[config] = metric if optimizer_log