BOAST 1.0.9 → 1.1.0

data/lib/BOAST/Language/Procedure.rb

@@ -4,6 +4,8 @@ module BOAST
     include PrivateStateAccessor
     include Inspectable
     extend Functor
+    include Annotation
+    ANNOTATIONS = [ :name, :parameters, :constants ]
 
     attr_reader :name
     attr_reader :parameters
@@ -214,21 +216,22 @@ module BOAST
       s += ")"
     end
 
-    def pr_align
-    end
-
     def open_c
       s = indent + decl_c_s + "{"
       output.puts s
       increment_indent_level
       constants.each { |c|
-        c.decl
+        BOAST::decl c
       }
       if lang == C then
         parameters.each { |p|
-          p.pr_align
+          align = p.align
+          BOAST::pr align if align
         }
       end
+      if @properties[:return] then
+        BOAST::decl @properties[:return]
+      end
       return self
     end
 
@@ -239,12 +242,16 @@ module BOAST
       s += indent + "integer, parameter :: wp=kind(1.0d0)"
       output.puts s
       constants.each { |c|
-        c.decl
+        BOAST::decl c
       }
       parameters.each { |p|
-        p.decl
-        p.pr_align
+        BOAST::decl p
+        align = p.align
+        BOAST::pr align if align
       }
+      if @properties[:return] then
+        BOAST::decl @properties[:return]
+      end
       return self
     end
 

data/lib/BOAST/Language/Variable.rb

@@ -13,7 +13,11 @@ module BOAST
       if v1 then
         if v2 then
           #@size = Expression::new(Substraction, v2, v1) + 1
-          @size = v2-v1+1
+          begin
+            @size = v2-v1+1
+          rescue
+            @size = Expression::new(Substraction, v2, v1) + 1
+          end
         else
           @size = v1
         end
@@ -29,8 +33,10 @@ module BOAST
         return "#{@val1}:#{@val2}"
       elsif lang == FORTRAN and get_array_start != 1 then
         return "#{get_array_start}:#{@size-(1+get_array_start)}"
+      elsif lang == FORTRAN and size.nil?
+        return "*"
       else
-        return @size
+        return @size.to_s
       end 
     end
 
@@ -47,13 +53,17 @@ module BOAST
         return @val2
       elsif @size
         if 0.equal?(get_array_start) then
+          return @size - 1
+        else
           if 1.equal?(get_array_start) then
-            return Expression::new(Addition, @size, get_array_start) - 1
-          else
             return @size
+          else
+            begin
+              return @size + get_array_start - 1
+            rescue
+              return Expression::new(Addition, @size, get_array_start) - 1
+            end
           end
-        else
-          return Expression::new(Substraction, @size, 1)
         end
       else
         return nil
@@ -115,6 +125,8 @@ module BOAST
     include Arithmetic
     include Inspectable
     extend Functor
+    include Annotation
+    ANNOTATIONS = [ :name, :type, :dimension ]
 
     alias_method :orig_method_missing, :method_missing
 
@@ -146,7 +158,7 @@ module BOAST
     attr_reader :restrict
     attr_reader :deferred_shape
     attr_reader :optional
-    attr_accessor :align
+    attr_accessor :alignment
     attr_accessor :replace_constant
     attr_accessor :force_replace_constant
 
@@ -191,7 +203,7 @@ module BOAST
     end
 
     def align?
-      !!@align
+      !!@alignment
     end
 
     def deferred_shape?
@@ -207,7 +219,7 @@ module BOAST
       @texture = hash[:texture]
       @allocate = hash[:allocate]
       @restrict = hash[:restrict]
-      @align = hash[:align]
+      @alignment = hash[:align]
       @deferred_shape = hash[:deferred_shape]
       @optional = hash[:optional]
       @force_replace_constant = false
@@ -271,8 +283,7 @@ module BOAST
 
     def dereference
       return copy("*(#{name})", :dimension => nil, :dim => nil, :direction => nil, :dir => nil) if [C, CL, CUDA].include?( lang )
-      return self if lang == FORTRAN
-      #return Expression::new("*",nil,self)
+      return Index::new(self, *(@dimension.collect { |d| d.start } ) ) if lang == FORTRAN
     end
    
     def struct_reference(x)
@@ -285,7 +296,7 @@ module BOAST
     end
 
     def [](*args)
-      return Index::new(self,args)
+      return Index::new(self,*args)
     end
  
     def finalize
@@ -310,12 +321,7 @@ module BOAST
       if dimension? and use_vla? and lang != FORTRAN  then
         s += "["
         s += @dimension.reverse.collect { |d|
-          dim = d.to_s
-          if dim then
-            dim.to_s
-          else
-            ""
-          end
+          d.to_s
         }.join("][")
         s += "]"
       end
@@ -386,12 +392,7 @@ module BOAST
         s += " #{@name}["
         s += "__restrict__ " if __restrict?
         s += @dimension.reverse.collect { |d|
-          dim = d.to_s
-          if dim then
-            dim.to_s
-          else
-            ""
-          end
+          d.to_s
         }.join("][")
         s += "]"
       else
@@ -413,8 +414,8 @@ module BOAST
           s +=")]"
         end 
       end
-      if __align? then
-        a = ( align? ? align : 1 )
+      if __align? and lang != CUDA then
+        a = ( align? ? alignment : 1 )
         a = ( a >= default_align ? a : default_align )
         s+= " __attribute((aligned(#{a})))"
       end
@@ -423,7 +424,7 @@ module BOAST
     end
 
     def decl_texture_s
-      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 (constant? or @direction == :in)
       dim_number = 1
       if dimension? then
@@ -454,69 +455,39 @@ module BOAST
       return self
     end
 
-    def pr_align_c_s(a)
-      return "__assume_aligned(#{@name}, #{a})"
-    end
-
-    def pr_align_c(a)
-      s = ""
-      s += indent
-      s += pr_align_c_s(a)
-      s += finalize
-      output.print s
-      return self
+    def align_c(a)
+      return FuncCall::new("__assume_aligned", @name, a)
     end
 
-    def pr_align_fortran_s(a)
-      return "!DIR$ ASSUME_ALIGNED #{@name}: #{a}"
+    def align_fortran(a)
+      return Pragma::new("DIR", "ASSUME_ALIGNED", "#{@name}: #{a}")
     end
 
-    def pr_align_fortran(a)
-      s = ""
-      s += indent
-      s += pr_align_fortran_s(a)
-      s += finalize
-      output.print s
-      return self
-    end
-
-    def pr_align
+    def align
       if dimension? then
         if align? or default_align > 1 then
-          a = ( align? ? align : 1 )
+          a = ( align? ? alignment : 1 )
           a = ( a >= default_align ? a : default_align )
-          return pr_align_c(a) if lang == C
-          return pr_align_fortran(a) if lang == FORTRAN
+          return align_c(a) if lang == C
+          return align_fortran(a) if lang == FORTRAN
         end
       end
+      return nil
     end
 
     def alloc_fortran( dims = nil )
-      s = ""
-      s += indent
-      s += "allocate( #{name}("
-      s += dims.collect { |d| d.to_s }.join(", ")
-      s += ") )"
-      s += finalize
-      output.print s
-      return self
+      return FuncCall::new(:allocate, FuncCall(name, * dims ) )
     end
 
     def alloc_c( dims = nil, align = get_address_size)
-      s = ""
-      s += indent
+      d = 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
-        s += "(#{@type.decl} *) posix_memalign( &#{name}, #{align}, sizeof(#{@type.decl})*("
+        return FuncCall::new(:posix_memalign, self.address, align, FuncCall::new(:sizeof, @type.decl) * d)
       else
-        s += "#{name} = (#{@type.decl} *) malloc( sizeof(#{@type.decl})*("
+        return self === FuncCall::new(:malloc, FuncCall::new(:sizeof, @type.decl) * d).cast(self)
       end
-      s += dims.collect { |d| d.to_s }.reverse.join(")*(")
-      s += ") )"
-      s += finalize
-      output.print s
-      return self
     end
 
     def alloc( dims = nil, align = get_address_size )
@@ -528,21 +499,11 @@ module BOAST
     end
 
     def dealloc_fortran
-      s = ""
-      s += indent
-      s += "deallocate( #{name} )"
-      s += finalize
-      output.print s
-      return self
+      return FuncCall::new(:deallocate, self)
     end
 
     def dealloc_c
-      s = ""
-      s += indent
-      s += "free( #{name} )"
-      s += finalize
-      output.print s
-      return self
+      return FuncCall::new(:free, self)
     end
 
     def dealloc
@@ -561,13 +522,10 @@ module BOAST
       if dimension? then
         s += ", dimension("
         s += @dimension.collect { |d|
-          dim = d.to_s
           if deferred_shape? or ( allocate? and @allocate == :heap )
             ":"
-          elsif dim then
-            dim.to_s
           else
-            "*"
+            d.to_s
           end
         }.join(", ")
         s += ")"
@@ -581,7 +539,7 @@ module BOAST
       s += finalize
       output.print s
       if dimension? and (align? or default_align > 1) and (constant? or ( allocate? and @allocate != :heap ) ) then
-        a = ( align? ? align : 1 )
+        a = ( align? ? alignment : 1 )
         a = ( a >= default_align ? a : default_align )
         s = ""
         s += indent

data/lib/BOAST/Language/While.rb

@@ -1,6 +1,8 @@
 module BOAST
 
   class While < ControlStructure
+    include Annotation
+    ANNOTATIONS = [ :condition ]
 
     attr_reader :condition
 
@@ -39,6 +41,7 @@ module BOAST
     end
 
     def pr(*args)
+      args = @args if args.length == 0 and @args
       open
       if @block then
         @block.call(*args)

data/lib/BOAST/Optimization/Optimization.rb

@@ -0,0 +1,241 @@
+module BOAST
+
+  class OptimizationParameter
+    attr_reader :name
+    attr_reader :values
+    def initialize( name, values )
+      @name = name
+      @values = values
+    end
+  end
+
+  class BooleanParameter < OptimizationParameter
+    def initialize( name )
+      super( name, [false, true] )
+    end
+  end
+
+  OP = OptimizationParameter
+  BP = BooleanParameter
+
+  class OptimizationSpace
+    attr_reader :parameters
+
+    def initialize( *parameters )
+      if parameters.length == 1 and parameters[0].is_a?(Hash) then
+        @parameters = []
+        parameters[0].each { |key, value|
+          @parameters.push( OptimizationParameter::new(key, value) )
+        }
+      else
+        @parameters = parameters
+      end
+    end
+
+    def to_h
+      h = {}
+      @parameters.each { |p|
+        h[p.name] = p.values
+      }
+      return h
+    end
+
+  end
+
+  class Optimizer
+    include PrivateStateAccessor
+    attr_reader :experiments
+    attr_reader :search_space
+    attr_reader :log
+
+    def initialize(search_space, options = {} )
+      @search_space = search_space
+      @experiments = 0
+      @log = {}
+    end
+  end
+
+  class GeneticOptimizer < Optimizer
+
+    def initialize(search_space, options = {} )
+      super
+      require 'darwinning'
+      s = <<EOF
+      @organism = Class::new(Darwinning::Organism) do
+        @@block = nil
+        def self.block
+          return @@block
+        end
+        def self.block=(block)
+          @@block = block
+        end
+        @@experiments = 0
+        def self.experiments
+          return @@experiments
+        end
+        def self.experiments=(experiments)
+          @@experiments = experiments
+        end
+EOF
+      @search_space.parameters.each { |param|
+      s += <<EOF
+        @genes.push( Darwinning::Gene.new(name: #{param.name.inspect}, value_range: #{param.values.inspect}) )
+EOF
+      }
+      s += <<EOF
+        def initialize(*args)
+          super
+        end
+
+        def fitness
+          return @fitness if @fitness
+          opts = {}
+          genes.each { |gene|
+            opts[gene.name] = genotypes[gene]
+          }
+          @fitness = @@block.call(opts)
+          @@experiments = @@experiments + 1
+          return fitness
+        end
+
+        def to_a
+          opts = {}
+          genes.each { |gene|
+            opts[gene.name] = genotypes[gene]
+          }
+          return [opts, fitness]
+        end
+
+        def to_s
+          return [opts, fitness].to_s
+        end
+
+      end
+EOF
+      eval s
+    end
+
+    def optimize(options={}, &block)
+      opts = { :population_size => 20,
+               :fitness_goal => 0,
+               :generations_limit => 100 }
+      opts.update(options)
+      opts[:organism] = @organism
+      @organism.block = block
+      @organism.experiments = 0
+      population = Darwinning::Population.new(opts)
+      population.evolve!
+      @experiments = @organism.experiments
+      return population.best_member.to_a
+    end
+
+  end
+
+  class BruteForceOptimizer < Optimizer
+
+    def initialize(search_space, options = {} )
+      super
+      @randomize = options[:randomize]
+    end
+
+    def points
+      params2 = @search_space.parameters.dup
+      param = params2.shift
+      pts = param.values.collect { |val| {param.name => val} }
+      if params2.size == 0 then
+        return pts
+      else
+        optim2 = BruteForceOptimizer::new(OptimizationSpace::new(*params2))
+        pts3=[]
+        pts.each{ |p1|
+          optim2.each { |p2|
+            pts3.push(p1.dup.update(p2))
+          }
+        }
+        return pts3
+      end
+    end
+
+    def each(&block)
+      return self.points.each(&block)
+    end
+
+    def each_random(&block)
+      return self.points.shuffle.each(&block)
+    end
+
+    def optimize(&block)
+      @experiments = 0
+      @log = {}
+      best = [nil, Float::INFINITY]
+      pts = points
+      pts.shuffle! if @randomize
+      pts.each { |config|
+        @experiments += 1
+        metric = block.call(config)
+        @log[config] = metric if optimizer_log
+        best = [config, metric] if metric < best[1]
+      }
+      if optimizer_log_file then
+        File::open(File::basename(optimizer_log_file,".yaml")+".yaml", "w") { |f|
+          f.print YAML::dump(@log)
+        }
+        File::open(File::basename(optimizer_log_file,".yaml")+"_parameters.yaml", "w") { |f|
+          f.print YAML::dump(@search_space.to_h)
+        }
+      end
+      return best
+    end
+
+  end
+
+  class GenericOptimization
+
+    attr_accessor :repeat
+    attr_reader :parameters
+
+    def size
+      return @parameters.size
+    end
+
+    def points
+      params2 = @parameters.dup
+      param = params2.shift
+      pts = param.values.collect { |val| {param.name => val} }
+      if params2.size == 0 then
+        return pts
+      else
+        optim2 = GenericOptimization::new(*params2)
+        pts3=[]
+        pts.each{ |p1|
+          optim2.each { |p2|
+            pts3.push(p1.dup.update(p2))
+          }
+        }
+        return pts3
+      end
+    end
+
+    def each(&block)
+      return self.points.each(&block)
+    end
+
+    def each_random(&block)
+      return self.points.shuffle.each(&block)
+    end
+
+    def initialize( *parameters )
+      if parameters.length == 1 and parameters[0].is_a?(Hash) then
+        @parameters = []
+        parameters[0].each { |key, value|
+          @parameters.push( OptimizationParameter::new(key, value) )
+        }
+      else
+        @parameters = parameters
+      end
+      @repeat = 3
+    end
+
+  end
+
+end