BOAST 0.9995 → 0.9996

data/lib/BOAST/Procedure.rb

@@ -1,8 +1,9 @@
 module BOAST
 
   class Procedure
-    include BOAST::Inspectable
-    extend BOAST::Functor
+    include PrivateStateAccessor
+    include Inspectable
+    extend Functor
 
     attr_reader :name
     attr_reader :parameters
@@ -25,7 +26,7 @@ module BOAST
       headers.each { |h|
         s += "#include <#{h}>\n"
       }
-      if BOAST::get_lang == CL then
+      if lang == CL then
         s += "__kernel "
         wgs = @properties[:reqd_work_group_size]
         if wgs then
@@ -61,34 +62,34 @@ module BOAST
     def boast_header(lang=C)
       s = boast_header_s(lang)
       s += ";\n"
-      BOAST::get_output.print s
+      output.print s
       return self
     end
 
     def call(*parameters)
       prefix = ""
-      prefix += "call " if BOAST::get_lang==FORTRAN
+      prefix += "call " if lang==FORTRAN
       f = FuncCall::new(@name, *parameters)
       f.prefix = prefix
       return f
     end
 
     def close
-      return self.close_fortran if BOAST::get_lang==FORTRAN
-      return self.close_c if [C, CL, CUDA].include?( BOAST::get_lang )
+      return close_fortran if lang==FORTRAN
+      return close_c if [C, CL, CUDA].include?( lang )
     end
 
     def close_c
-      BOAST::decrement_indent_level
+      decrement_indent_level
       s = ""
       s += "  return #{@properties[:return]};\n" if @properties[:return]
       s += "}"
-      BOAST::get_output.puts s
+      output.puts s
       return self
     end
 
     def close_fortran
-      BOAST::decrement_indent_level
+      decrement_indent_level
       s = ""
       if @properties[:return] then
         s += "  #{@name} = #{@properties[:return]}\n"
@@ -96,22 +97,22 @@ module BOAST
       else
         s += "END SUBROUTINE #{@name}"
       end
-      BOAST::get_output.puts s
+      output.puts s
       return self
     end
 
-    def print
-      self.open
+    def pr
+      open
       if @block then
         @block.call
-        self.close
+        close
       end
       return self
     end
 
     def decl
-      return self.decl_fortran if BOAST::get_lang==FORTRAN
-      return self.decl_c if [C, CL, CUDA].include?( BOAST::get_lang )
+      return decl_fortran if lang==FORTRAN
+      return decl_c if [C, CL, CUDA].include?( lang )
     end
 
     def decl_fortran
@@ -120,7 +121,7 @@ module BOAST
 
     def decl_c_s
       s = ""
-      if BOAST::get_lang == CL then
+      if lang == CL then
         if @properties[:local] then
           s += "static "
         else
@@ -130,7 +131,7 @@ module BOAST
             s += "__attribute__((reqd_work_group_size(#{wgs[0]},#{wgs[1]},#{wgs[2]}))) "
           end
         end
-      elsif BOAST::get_lang == CUDA then
+      elsif lang == CUDA then
         if @properties[:local] then
           s += "static __device__ "
         else
@@ -162,26 +163,21 @@ module BOAST
 
     def decl_c
       s = decl_c_s + ";"
-      BOAST::get_output.puts s
+      output.puts s
       return self
     end
 
     def open
-      return self.open_fortran if BOAST::get_lang==FORTRAN
-      return self.open_c if [C, CL, CUDA].include?( BOAST::get_lang )
+      return open_fortran if lang==FORTRAN
+      return open_c if [C, CL, CUDA].include?( lang )
     end
 
-    def open_c
-      s = decl_c_s + "{"
-      BOAST::get_output.puts s
-      BOAST::increment_indent_level
-      constants.each { |c|
-        c.decl
-      }
-      return self
+    def to_s
+      return decl_c_s if [C, CL, CUDA].include?( lang )
+      return to_s_fortran if lang==FORTRAN
     end
 
-    def open_fortran
+    def to_s_fortran
       s = ""
       if @properties[:return] then
         s += "#{@properties[:return].type.decl} FUNCTION "
@@ -190,10 +186,25 @@ module BOAST
       end
       s += "#{@name}("
       s += parameters.join(", ")
-      s += ")\n"
-      BOAST::increment_indent_level
-      s += BOAST::indent + "integer, parameter :: wp=kind(1.0d0)"
-      BOAST::get_output.puts s
+      s += ")"
+    end
+
+    def open_c
+      s = decl_c_s + "{"
+      output.puts s
+      increment_indent_level
+      constants.each { |c|
+        c.decl
+      }
+      return self
+    end
+
+    def open_fortran
+      s = to_s_fortran
+      s += "\n"
+      increment_indent_level
+      s += indent + "integer, parameter :: wp=kind(1.0d0)"
+      output.puts s
       constants.each { |c|
         c.decl
       }
@@ -202,6 +213,7 @@ module BOAST
       }
       return self
     end
+
   end
 
 end

data/lib/BOAST/State.rb

@@ -0,0 +1,79 @@
+module BOAST
+
+  def self.state_accessor(*args)
+    args.each { |arg|
+      s = <<EOF
+  def #{arg}=(val)
+    @@#{arg} = val
+  end
+  module_function :#{arg}=
+  def #{arg}
+    @@#{arg}
+  end
+  module_function :#{arg}
+  def set_#{arg}(val)
+    @@#{arg} = val
+  end
+  module_function :set_#{arg}
+  def get_#{arg}
+    @@#{arg}
+  end
+  module_function :get_#{arg}
+EOF
+      eval s
+    }
+  end
+
+  def self.boolean_state_accessor(*args)
+    self.state_accessor(*args)
+    args.each { |arg|
+      s = <<EOF
+  def #{arg}?
+    !!@@#{arg}
+  end
+  module_function :#{arg}?
+EOF
+      eval s
+    }
+  end
+
+  module PrivateStateAccessor
+
+    def self.private_state_accessor(*args)
+      args.each { |arg|
+        s = <<EOF
+    private
+    def #{arg}=(val)
+      BOAST::#{arg}= val
+    end
+    def #{arg}
+      BOAST::#{arg}
+    end
+    def set_#{arg}(val)
+      BOAST::set_#{arg}(val)
+    end
+    def get_#{arg}
+      BOAST::get_#{arg}
+    end
+EOF
+        eval s
+      }
+    end
+  
+    def self.private_boolean_state_accessor(*args)
+      self.private_state_accessor(*args)
+      args.each { |arg|
+        s = <<EOF
+    private
+    def #{arg}?
+      BOAST::#{arg}?
+    end
+EOF
+        eval s
+      }
+    end
+
+  end
+
+end
+

data/lib/BOAST/Transitions.rb

@@ -1,9 +1,11 @@
 module BOAST
+
   module TypeTransition
+
     @@transitions = Hash::new { |hash, key| hash[key] = Hash::new }
+
     def get_transition(type1, type2, operator)
       #STDERR.puts @@transitions.inspect
-      #STDERR.puts @@transitions[t1][t2].inspec
       ops = @@transitions[[type1,type2]]
       raise "Types #{[type1,type2]} have no relation!" if not ops
       t = ops[operator]
@@ -21,19 +23,25 @@ module BOAST
        signed = false
        size = nil
        vector_length = 1
-       return_type, operator = get_transition(var1.type.class, var2.type.class, operator)
+       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 var1.type.class == return_type and var2.type.class == return_type then
+       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
-         [BOAST::Variable::new("dummy", return_type, :size => size, :signed => signed, :vector_length => vector_length), operator]
+         [Variable::new("dummy", return_type, :size => size, :signed => signed, :vector_length => vector_length), operator]
        elsif var1.type.class == return_type then
          return [var1, operator]
-       elsif var2.type.class == return_type then
+       else # var2.type.class == return_type then
          return [var2, operator]
        end
      end
+
   end
+
 end

data/lib/BOAST/Variable.rb

@@ -1,8 +1,9 @@
 module BOAST
 
   class Dimension
-    include BOAST::Inspectable
-    extend BOAST::Functor
+    include PrivateStateAccessor
+    include Inspectable
+    extend Functor
 
     attr_reader :val1
     attr_reader :val2
@@ -13,8 +14,8 @@ module BOAST
       @val1 = nil
       @val2 = nil
       if v2.nil? and v1 then
-        @val1 = BOAST::get_array_start
-        @val2 = v1 + BOAST::get_array_start - 1
+        @val1 = get_array_start
+        @val2 = v1 + get_array_start - 1
         @size = v1
       else
         @val1 = v1
@@ -25,11 +26,11 @@ module BOAST
     def to_s
       s = ""
       if @val2 then
-        if BOAST::get_lang == BOAST::FORTRAN then
+        if lang == FORTRAN then
           s += @val1.to_s
           s += ":"
           s += @val2.to_s
-        elsif [BOAST::C, BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang ) then
+        elsif [C, CL, CUDA].include?( lang ) then
           s += (@val2 - @val1 + 1).to_s
         end
       elsif @val1.nil? then
@@ -42,7 +43,8 @@ module BOAST
   end
 
   class ConstArray < Array
-    include BOAST::Inspectable
+    include PrivateStateAccessor
+    include Inspectable
 
     def initialize(array,type = nil)
       super(array)
@@ -50,15 +52,15 @@ module BOAST
     end
 
     def to_s
-      return self.to_s_fortran if BOAST::get_lang == BOAST::FORTRAN
-      return self.to_s_c if [BOAST::C, BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang )
+      return to_s_fortran if lang == FORTRAN
+      return to_s_c if [C, CL, CUDA].include?( lang )
     end
 
     def to_s_fortran
       s = ""
-      return s if self.first.nil?
+      return s if first.nil?
       s += "(/ &\n"
-      s += self.first.to_s
+      s += first.to_s
       s += "_wp" if @type and @type.size == 8
       self[1..-1].each { |v|
         s += ", &\n"+v.to_s
@@ -69,9 +71,9 @@ module BOAST
 
     def to_s_c
       s = ""
-      return s if self.first.nil?
+      return s if first.nil?
       s += "{\n"
-      s += self.first.to_s 
+      s += first.to_s 
       self[1..-1].each { |v|
         s += ",\n"+v.to_s
       }
@@ -80,17 +82,19 @@ module BOAST
   end
 
   class Variable
-    include BOAST::Arithmetic
-    include BOAST::Inspectable
-    extend BOAST::Functor
+    include PrivateStateAccessor
+    include Arithmetic
+    include Inspectable
+    extend Functor
 
     alias_method :orig_method_missing, :method_missing
 
     def method_missing(m, *a, &b)
-      return self.struct_reference(type.members[m.to_s]) if type.members[m.to_s]
-#      return self.get_element(m.to_s) if type.getters[m.to_s]
-#      return self.set_element(m.to_s) if type.setters[m.to_s]
-      return self.orig_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])
+      else
+        return orig_method_missing(m, *a, &b)
+      end
     end
 
     attr_reader :name
@@ -106,6 +110,38 @@ module BOAST
     attr_accessor :replace_constant
     attr_accessor :force_replace_constant
 
+    def constant?
+      !!@constant
+    end
+
+    def allocate?
+      !!@allocate
+    end
+
+    def texture?
+      !!@texture
+    end
+
+    def local?
+      !!@local
+    end
+
+    def restrict?
+      !!@restrict
+    end
+
+    def replace_constant?
+      !!@replace_constant
+    end
+
+    def force_replace_constant?
+      !!@force_replace_constant
+    end
+
+    def dimension?
+      !!@dimension
+    end
+
     def initialize(name,type,hash={})
       @name = name.to_s
       @direction = hash[:direction] ? hash[:direction] : hash[:dir]
@@ -121,19 +157,19 @@ module BOAST
       else
         @replace_constant = true
       end
-      if @texture and BOAST::get_lang == BOAST::CL then
-        @sampler = Variable::new("sampler_#{name}", BOAST::CustomType,:type_name => "sampler_t" ,:replace_constant => false, :constant => "CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST")
+      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(hash)
       @options = hash
-      if (@direction == :out or @direction == :inout) and not @dimension then
+      if (@direction == :out or @direction == :inout) and not dimension? then
         @scalar_output = true
       else
         @scalar_output = false
       end
-      @dimension = [@dimension].flatten if @dimension
+      @dimension = [@dimension].flatten if dimension?
     end
 
     def copy(name=nil,options={})
@@ -145,7 +181,7 @@ module BOAST
       return Variable::new(name, @type.class, h)
     end
 
-    def Variable.from_type(name, type, options={})
+    def self.from_type(name, type, options={})
       hash = type.to_hash
       options.each { |k,v|
         hash[k] = v
@@ -156,13 +192,13 @@ module BOAST
     end
   
     def to_s
-      if @force_replace_constant or ( @replace_constant and @constant and BOAST::get_replace_constants and not @dimension ) then
+      if force_replace_constant? or ( replace_constant? and constant? and replace_constants? and not dimension? ) then
         s = @constant.to_s 
-        s += "_wp" if BOAST::get_lang == BOAST::FORTRAN and @type and @type.size == 8
+        s += "_wp" if lang == FORTRAN and @type and @type.size == 8
         return s
       end
-      if @scalar_output and [BOAST::C, BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang ) then
-        return "(*#{self.name})"
+      if @scalar_output and [C, CL, CUDA].include?( lang ) then
+        return "(*#{name})"
       end
       return @name
     end
@@ -172,18 +208,18 @@ module BOAST
     end
 
     def set(x)
-      return Expression::new(BOAST::Set, self, x)
+      return Expression::new(Set, self, x)
     end
 
     def dereference
-      return self.copy("*(#{self.name})", :dimension => nil, :dim => nil, :direction => nil, :dir => nil) if [BOAST::C, BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang )
-      return self if BOAST::get_lang == BOAST::FORTRAN
+      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)
     end
    
     def struct_reference(x)
-      return x.copy(self.name+"."+x.name) if [BOAST::C, BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang )
-      return x.copy(self.name+"%"+x.name) if BOAST::get_lang == BOAST::FORTRAN
+      return x.copy(name+"."+x.name) if [C, CL, CUDA].include?( lang )
+      return x.copy(name+"%"+x.name) if lang == FORTRAN
     end
  
     def inc
@@ -196,20 +232,20 @@ module BOAST
  
     def finalize
        s = ""
-       s += ";" if [BOAST::C, BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang )
+       s += ";" if [C, CL, CUDA].include?( lang )
        s+="\n"
        return s
     end
 
     def boast_header(lang=C)
-      return decl_texture_s if @texture
+      return decl_texture_s if texture?
       s = ""
-      s += "const " if @constant or @direction == :in
+      s += "const " if constant? or @direction == :in
       s += @type.decl
-      if @dimension then
+      if dimension? then
         s += " *"
       end
-      if not @dimension and ( lang == BOAST::FORTRAN or @direction == :out or @direction == :inout ) then
+      if not dimension? and ( lang == FORTRAN or @direction == :out or @direction == :inout ) then
         s += " *"
       end
       s += " #{@name}"
@@ -217,54 +253,54 @@ module BOAST
     end
 
     def decl
-      return self.decl_fortran if BOAST::get_lang == BOAST::FORTRAN
-      return self.decl_c if [BOAST::C, BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang )
+      return decl_fortran if lang == FORTRAN
+      return decl_c if [C, CL, CUDA].include?( lang )
     end
 
     def decl_c_s(device = false)
-      return decl_texture_s if @texture
+      return decl_texture_s if texture?
       s = ""
-      s += "const " if @constant or @direction == :in
-      s += "__global " if @direction and @dimension and not (@options[:register] or @options[:private] or @local) and BOAST::get_lang == BOAST::CL
-      s += "__local " if @local and BOAST::get_lang == BOAST::CL
-      s += "__shared__ " if @local and not device and BOAST::get_lang == BOAST::CUDA
+      s += "const " if constant? or @direction == :in
+      s += "__global " if @direction and dimension? and not (@options[:register] or @options[:private] or local?) and lang == CL
+      s += "__local " if local? and lang == CL
+      s += "__shared__ " if local? and not device and lang == CUDA
       s += @type.decl
-      if(@dimension and not @constant and not @allocate and (not @local or (@local and device))) then
+      if dimension? and not constant? and not allocate? and (not local? or (local? and device)) then
         s += " *"
-        if @restrict then
-          if BOAST::get_lang == BOAST::CL
+        if restrict? then
+          if lang == CL
             s += " restrict"
           else
             s += " __restrict__"
           end
         end
       end
-      if not @dimension and ( @direction == :out or @direction == :inout ) then
+      if not dimension? and ( @direction == :out or @direction == :inout ) then
         s += " *"
       end
       s += " #{@name}"
-      if @dimension and @constant then
+      if dimension? and constant? then
         s += "[]"
       end
-      if @dimension and ((@local and not device) or (@allocate and not @constant)) then
+      if dimension? and ((local? and not device) or (allocate? and not constant?)) then
          s +="["
          s += @dimension.reverse.join("*")
          s +="]"
       end 
-      s += " = #{@constant}" if @constant
+      s += " = #{@constant}" if constant?
       return s
     end
 
     def decl_texture_s
-      raise "Unsupported language #{BOAST::get_lang} for texture!" if not [BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang )
-      raise "Write is unsupported for textures!" if not (@constant or @direction == :in)
+      raise "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
+      if dimension? then
         dim_number == @dimension.size
       end
       raise "Unsupported number of dimension: #{dim_number}!" if dim_number > 3
       s = ""
-      if BOAST::get_lang == BOAST::CL then
+      if lang == CL then
         s += "__read_only "
         if dim_number < 3 then
           s += "image2d_t " #from OCL 1.2+ image1d_t is defined
@@ -280,21 +316,21 @@ module BOAST
 
     def decl_c
       s = ""
-      s += BOAST::indent
-      s += self.decl_c_s
-      s += self.finalize
-      BOAST::get_output.print s
+      s += indent
+      s += decl_c_s
+      s += finalize
+      output.print s
       return self
     end
 
 
     def decl_fortran
       s = ""
-      s += BOAST::indent
+      s += indent
       s += @type.decl
       s += ", intent(#{@direction})" if @direction 
-      s += ", parameter" if @constant
-      if(@dimension) then
+      s += ", parameter" if constant?
+      if dimension? then
         s += ", dimension("
         dim = @dimension[0].to_s
         if dim then
@@ -308,12 +344,12 @@ module BOAST
         s += ")"
       end
       s += " :: #{@name}"
-      if @constant then
+      if constant? then
         s += " = #{@constant}"
-        s += "_wp" if not @dimension and @type and @type.size == 8
+        s += "_wp" if not dimension? and @type and @type.size == 8
       end
-      s += self.finalize
-      BOAST::get_output.print s
+      s += finalize
+      output.print s
       return self
     end