BOAST 0.995 → 0.996

data/lib/BOAST/Procedure.rb

@@ -0,0 +1,187 @@
+module BOAST
+  class Procedure
+    def self.parens(*args,&block)
+      return self::new(*args,&block)
+    end
+
+    attr_reader :name
+    attr_reader :parameters
+    attr_reader :constants
+    attr_reader :properties
+    attr_reader :headers
+    def initialize(name, parameters=[], constants=[], properties={}, &block)
+      @name = name
+      @parameters = parameters
+      @constants = constants
+      @block = block
+      @properties = properties
+      @headers = properties[:headers]
+      @headers = [] if not @headers
+    end
+
+    def header(lang=C,final=true)
+      s = ""
+      headers.each { |h|
+        s += "#include <#{h}>\n"
+      }
+      if BOAST::get_lang == CL then
+        s += "__kernel "
+        wgs = @properties[:reqd_work_group_size]
+        if wgs then
+          s += "__attribute__((reqd_work_group_size(#{wgs[0]},#{wgs[1]},#{wgs[2]}))) "
+        end
+      end
+      trailer = ""
+      trailer += "_" if lang == FORTRAN
+      trailer += "_wrapper" if lang == CUDA
+      if @properties[:return] then
+        s += "#{@properties[:return].type.decl} "
+      elsif lang == CUDA
+        s += "unsigned long long int "
+      else
+        s += "void "
+      end
+      s += "#{@name}#{trailer}("
+      if parameters.first then
+        s += parameters.first.header(lang,false)
+        parameters[1..-1].each { |p|
+          s += ", "
+          s += p.header(lang,false)
+        }
+      end
+      if lang == CUDA then
+        s += ", " if parameters.first
+        s += "size_t *block_number, size_t *block_size"
+      end
+      s += ")"
+      s += ";\n" if final
+      BOAST::get_output.print s if final
+      return s
+    end
+
+    def call(*parameters)
+      prefix = ""
+      prefix += "call " if BOAST::get_lang==FORTRAN
+      f = FuncCall::new(@name, *parameters)
+      f.prefix = prefix
+      return f
+    end
+    def decl(final=true)
+      return self.decl_fortran(final) if BOAST::get_lang==FORTRAN
+      return self.decl_c(final) if [C, CL, CUDA].include?( BOAST::get_lang )
+    end
+    def close(final=true)
+      return self.close_fortran(final) if BOAST::get_lang==FORTRAN
+      return self.close_c(final) if [C, CL, CUDA].include?( BOAST::get_lang )
+    end
+    def close_c(final=true)
+      BOAST::decrement_indent_level
+      s = ""
+      s += "  return #{@properties[:return]};\n" if @properties[:return]
+      s += "}"
+      BOAST::get_output.puts s if final
+      return s
+    end
+    def close_fortran(final=true)
+      BOAST::decrement_indent_level
+      s = ""
+      if @properties[:return] then
+        s += "  #{@name} = #{@properties[:return]}\n"
+        s += "END FUNCTION #{@name}"
+      else
+        s += "END SUBROUTINE #{@name}"
+      end
+      BOAST::get_output.puts s if final
+      return s
+    end
+
+    def print(final=true)
+      s = self.decl
+      if @block then
+        @block.call
+        s += self.close
+      end
+      return s
+    end
+
+    def decl_c(final=true)
+      s = ""
+#      s += self.header(BOAST::get_lang,false)
+#      s += ";\n"
+      if BOAST::get_lang == CL then
+        if not @properties[:local] then
+          s += "__kernel "
+          wgs = @properties[:reqd_work_group_size]
+          if wgs then
+            s += "__attribute__((reqd_work_group_size(#{wgs[0]},#{wgs[1]},#{wgs[2]}))) "
+          end
+        end
+      elsif BOAST::get_lang == CUDA then
+        if @properties[:local] then
+          s += "static __device__ "
+        else
+          s += "__global__ "
+          wgs = @properties[:reqd_work_group_size]
+          if wgs then
+            s += "__launch_bounds__(#{wgs[0]}*#{wgs[1]}*#{wgs[2]}) "
+          end
+        end
+      end
+      if @properties[:qualifiers] then
+        s += "#{@properties[:qualifiers]} "
+      end
+      if @properties[:return] then
+        s += "#{@properties[:return].type.decl} "
+      else
+        s += "void "
+      end
+      s += "#{@name}("
+      if parameters.first then
+        s += parameters.first.decl(false, @properties[:local])
+        parameters[1..-1].each { |p|
+          s += ", "+p.decl(false, @properties[:local])
+        }
+      end
+      s += "){\n"
+      BOAST::increment_indent_level
+      constants.each { |c|
+        s += " "*BOAST::get_indent_level
+        s += c.decl(false)
+        s += ";\n"
+      }
+      BOAST::get_output.print s if final
+      return s
+    end
+    def decl_fortran(final=true)
+      s = ""
+      if @properties[:return] then
+        s += "#{@properties[:return].type.decl} FUNCTION "
+      else
+        s += "SUBROUTINE "
+      end
+      s += "#{@name}("
+      if parameters.first then
+        s += parameters.first
+        parameters[1..-1].each { |p|
+          s += ", "+p
+        }
+      end
+      s += ")\n"
+      BOAST::increment_indent_level
+      s += " "*BOAST::get_indent_level + "integer, parameter :: wp=kind(1.0d0)\n"
+      constants.each { |c|
+        s += " "*BOAST::get_indent_level
+        s += c.decl(false)
+        s += "\n"
+      }
+      parameters.each { |p|
+        s += " "*BOAST::get_indent_level
+        s += p.decl(false)
+        s += "\n"
+      }
+      BOAST::get_output.print s if final
+      return s
+    end
+  end
+
+end

data/lib/BOAST/Variable.rb

@@ -0,0 +1,345 @@
+module BOAST
+
+  class Dimension
+    def self.parens(*args,&block)
+      return self::new(*args,&block)
+    end
+
+    attr_reader :val1
+    attr_reader :val2
+    attr_reader :size
+    def initialize(v1=nil,v2=nil)
+      @size = nil
+      @val1 = nil
+      @val2 = nil
+      if v2.nil? and v1 then
+        @val1 = BOAST::get_array_start
+        @val2 = v1 + BOAST::get_array_start - 1
+        @size = v1
+      else
+        @val1 = v1
+        @val2 = v2
+      end
+    end
+
+    def to_str
+      s = ""
+      if @val2 then
+        if BOAST::get_lang == BOAST::FORTRAN then
+          s += @val1.to_s
+          s += ":"
+          s += @val2.to_s
+        elsif [BOAST::C, BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang ) then
+          s += (@val2 - @val1 + 1).to_s
+        end
+      elsif @val1.nil? then
+        return nil
+      else
+        s += @val1.to_s
+      end
+      return s
+    end
+    def to_s
+      self.to_str
+    end
+  end
+
+  class ConstArray < Array
+    def initialize(array,type = nil)
+      super(array)
+      @type = type::new if type
+    end
+    def to_s
+      self.to_str
+    end
+    def to_str
+      return self.to_str_fortran if BOAST::get_lang == BOAST::FORTRAN
+      return self.to_str_c if [BOAST::C, BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang )
+    end
+    def to_str_fortran
+      s = ""
+      return s if self.first.nil?
+      s += "(/ &\n"
+      s += self.first.to_s
+      s += "_wp" if @type and @type.size == 8
+      self[1..-1].each { |v|
+        s += ", &\n"+v.to_s
+        s += "_wp" if @type and @type.size == 8
+      }
+      s += " /)"
+    end
+    def to_str_c
+      s = ""
+      return s if self.first.nil?
+      s += "{\n"
+      s += self.first.to_s 
+      self[1..-1].each { |v|
+        s += ",\n"+v.to_s
+      }
+      s += "}"
+    end
+  end
+
+  class Variable
+    include BOAST::Arithmetic
+
+    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)
+    end
+
+    def self.parens(*args,&block)
+      return self::new(*args,&block)
+    end
+
+    attr_reader :name
+    attr_accessor :direction
+    attr_accessor :constant
+    attr_reader :allocate
+    attr_reader :type
+    attr_reader :dimension
+    attr_reader :local
+    attr_reader :texture
+    attr_reader :sampler
+    attr_reader :restrict
+    attr_accessor :replace_constant
+    attr_accessor :force_replace_constant
+
+    def initialize(name,type,hash={})
+      @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]
+      @force_replace_constant = false
+      if not hash[:replace_constant].nil? then
+        @replace_constant = hash[:replace_constant]
+      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")
+      else
+        @sampler = nil
+      end
+      @type = type::new(hash)
+      @hash = hash
+      if (@direction == :out or @direction == :inout) and not @dimension then
+        @scalar_output = true
+      else
+        @scalar_output = false
+      end
+    end
+
+    def copy(name=nil,options={})
+      name = @name if not name
+      h = @hash.clone
+      options.each { |k,v|
+        h[k] = v
+      }
+      return Variable::new(name, @type.class, h)
+    end
+
+    def Variable.from_type(name, type, options={})
+      hash = type.to_hash
+      options.each { |k,v|
+        hash[k] = v
+      }
+      hash[:direction] = nil
+      hash[:dir] = nil
+      return Variable::new(name, type.class, hash)
+    end
+  
+    def to_s
+      self.to_str
+    end    
+
+    def to_str
+      if @force_replace_constant or ( @replace_constant and @constant and BOAST::get_replace_constants and not @dimension ) then
+        s = @constant.to_s 
+        s += "_wp" if BOAST::get_lang == BOAST::FORTRAN and @type and @type.size == 8
+        return s
+      end
+      if @scalar_output then
+        return "(*#{self.name})"
+      end
+      return @name
+    end
+
+    def to_var
+      return self
+    end
+
+    def set(x)
+      return Expression::new(BOAST::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 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
+    end
+ 
+    def inc
+      return Expression::new("++",self,nil)
+    end
+
+    def [](*args)
+      return Index::new(self,args)
+    end
+ 
+    def indent
+       return " "*BOAST::get_indent_level
+    end
+
+    def finalize
+       s = ""
+       s += ";" if [BOAST::C, BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang )
+       s+="\n"
+       return s
+    end
+
+    def decl_c(final=true, device=false)
+      return decl_texture(final) if @texture
+      s = ""
+      s += self.indent if final
+      s += "const " if @constant or @direction == :in
+      s += "__global " if @direction and @dimension and not (@hash[:register] or @hash[: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 += @type.decl
+      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
+            s += " restrict"
+          else
+            s += " __restrict__"
+          end
+        end
+      end
+      if not @dimension and ( @direction == :out or @direction == :inout ) then
+        s += " *"
+      end
+      s += " #{@name}"
+      if @dimension and @constant then
+        s += "[]"
+      end
+      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 += self.finalize if final
+      BOAST::get_output.print s if final
+      return s
+    end
+
+    def header(lang=C,final=true)
+      return decl_texture(final) if @texture
+      s = ""
+      s += self.indent if final
+      s += "const " if @constant or @direction == :in
+      s += "__global " if @direction and @dimension and BOAST::get_lang == BOAST::CL
+      s += "__local " if @local and BOAST::get_lang == BOAST::CL
+      s += "__shared__ " if @local and BOAST::get_lang == BOAST::CUDA
+      s += @type.decl
+      if(@dimension and not @constant and not @local) then
+        s += " *"
+      end
+      if not @dimension and ( lang == BOAST::FORTRAN or @direction == :out or @direction == :inout ) then
+        s += " *"
+      end
+      s += " #{@name}"
+      if(@dimension and @constant) then
+        s += "[]"
+      end
+      if(@dimension and @local) then
+         s +="["
+         s += @dimension.reverse.join("*")
+         s +="]"
+      end 
+      s += " = #{@constant}" if @constant
+      s += self.finalize if final
+      BOAST::get_output.print s if final
+      return s
+    end
+
+    def decl(final=true,device=false)
+      return self.decl_fortran(final) if BOAST::get_lang == BOAST::FORTRAN
+      return self.decl_c(final, device) if [BOAST::C, BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang )
+    end
+
+    def decl_texture(final=true)
+      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)
+      dim_number = 1
+      if @dimension then
+        dim_number == @dimension.size
+      end
+      raise "Unsupported number of dimension: #{dim_number}!" if dim_number > 3
+      s = ""
+      s += self.indent if final
+      if BOAST::get_lang == BOAST::CL then
+        s += "__read_only "
+        if dim_number < 3 then
+          s += "image2d_t " #from OCL 1.2+ image1d_t is defined
+        else
+          s += "image3d_t "
+        end
+      else
+        s += "texture<#{@type.decl}, cudaTextureType#{dim_number}D, cudaReadModeElementType> "
+      end
+      s += @name
+      s += self.finalize if final
+      BOAST::get_output.print s if final
+      return s
+    end
+
+
+    def decl_fortran(final=true)
+      s = ""
+      s += self.indent if final
+      s += @type.decl
+      s += ", intent(#{@direction})" if @direction 
+      s += ", parameter" if @constant
+      if(@dimension) then
+        s += ", dimension("
+        dim = @dimension[0].to_str
+        if dim then
+          s += dim
+          @dimension[1..-1].each { |d|
+             s += ", "
+             s += d
+          }
+        else
+          s += "*"
+        end
+        s += ")"
+      end
+      s += " :: #{@name}"
+      if @constant
+        s += " = #{@constant}"
+        s += "_wp" if not @dimension and @type and @type.size == 8
+      end
+      s += self.finalize if final
+      BOAST::get_output.print s if final
+      return s
+    end
+
+  end
+
+end

data/lib/BOAST/While.rb

@@ -0,0 +1,67 @@
+module BOAST
+
+  class While
+    def self.parens(*args,&block)
+      return self::new(*args,&block)
+    end
+
+    attr_reader :condition
+    def initialize(condition, &block)
+      @condition = condition
+      @block = block
+    end
+    def to_s
+      self.to_str
+    end
+    def to_str
+      return self.to_str_fortran if BOAST::get_lang == FORTRAN
+      return self.to_str_c if [C, CL, CUDA].include?( BOAST::get_lang )
+    end
+    def to_str_fortran
+      s = ""
+      s += "do while( #{@condition} )"
+      return s
+    end
+    def to_str_c
+      s = ""
+      s += "while(#{@condition}){"
+      return s
+    end
+    def print(*args)
+      final = true
+      s=""
+      s += " "*BOAST::get_indent_level if final
+      s += self.to_str
+      BOAST::increment_indent_level      
+      BOAST::get_output.puts s if final
+      if @block then
+        s += "\n"
+        @block.call(*args)
+        s += self.close
+      end
+      return s
+    end
+    def close(final=true)
+      return self.close_fortran(final) if BOAST::get_lang == FORTRAN
+      return self.close_c(final) if [C, CL, CUDA].include?( BOAST::get_lang )
+    end
+    def close_c(final=true)
+      s = ""
+      BOAST::decrement_indent_level      
+      s += " "*BOAST::get_indent_level if final
+      s += "}"
+      BOAST::get_output.puts s if final
+      return s
+    end
+    def close_fortran(final=true)
+      s = ""
+      BOAST::decrement_indent_level      
+      s += " "*BOAST::get_indent_level if final
+      s += "end do"
+      BOAST::get_output.puts s if final
+      return s
+    end
+
+  end
+
+end

data/lib/BOAST.rb

@@ -1,6 +1,17 @@
 require 'BOAST/Transitions.rb'
+require 'BOAST/Arithmetic.rb'
 require 'BOAST/Operators.rb'
 require 'BOAST/DataTypes.rb'
+require 'BOAST/Expression.rb'
+require 'BOAST/Index.rb'
+require 'BOAST/Variable.rb'
+require 'BOAST/FuncCall.rb'
+require 'BOAST/Procedure.rb'
+require 'BOAST/If.rb'
+require 'BOAST/For.rb'
+require 'BOAST/Case.rb'
+require 'BOAST/While.rb'
+require 'BOAST/Pragma.rb'
 require 'BOAST/Algorithm.rb'
 require 'BOAST/CKernel.rb'
 require 'BOAST/Parens.rb'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: BOAST
 version: !ruby/object:Gem::Version
-  version: '0.995'
+  version: '0.996'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-30 00:00:00.000000000 Z
+date: 2014-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: narray
@@ -76,6 +76,17 @@ files:
 - lib/BOAST/Parens.rb
 - lib/BOAST/Operators.rb
 - lib/BOAST/DataTypes.rb
+- lib/BOAST/Arithmetic.rb
+- lib/BOAST/Expression.rb
+- lib/BOAST/Index.rb
+- lib/BOAST/Variable.rb
+- lib/BOAST/Procedure.rb
+- lib/BOAST/If.rb
+- lib/BOAST/For.rb
+- lib/BOAST/Case.rb
+- lib/BOAST/While.rb
+- lib/BOAST/FuncCall.rb
+- lib/BOAST/Pragma.rb
 homepage: https://forge.imag.fr/projects/boast/
 licenses:
 - BSD