BOAST 1.2.2 → 1.3.0

data/lib/BOAST/Language/Pragma.rb

@@ -1,5 +1,6 @@
 module BOAST
 
+  # @!parse module Functors; functorize Pragma; end
   class Pragma
     include PrivateStateAccessor
     include Inspectable

data/lib/BOAST/Language/Print.rb

@@ -1,9 +1,12 @@
 module BOAST
 
+
+   # @deprecated
    def self.print(a, *args)
      pr(a, *args)
    end
 
+   # @deprecated
    def self.open(a)
      opn(a)
    end

data/lib/BOAST/Language/Procedure.rb

@@ -1,5 +1,6 @@
 module BOAST
 
+  # @!parse module Functors; functorize Procedure; end
   class Procedure
     include PrivateStateAccessor
     include Inspectable
@@ -13,54 +14,18 @@ module BOAST
     attr_reader :properties
     attr_reader :headers
 
-    def initialize(name, parameters=[], constants=[], properties={}, &block)
+    def initialize(name, parameters=[], properties={}, &block)
       @name = name
       @parameters = parameters
-      @constants = constants
+      @constants = properties[:constants]
+      @constants = [] unless @constants
       @block = block
       @properties = properties
       @headers = properties[:headers]
-      @headers = [] if not @headers
-    end
-
-    def boast_header_s( lang=C )
-      s = ""
-      headers.each { |h|
-        s += "#include <#{h}>\n"
-      }
-      if 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.boast_header(lang)
-        parameters[1..-1].each { |p|
-          s += ", "
-          s += p.boast_header(lang)
-        }
-      end
-      if lang == CUDA then
-        s += ", " if parameters.first
-        s += "size_t *block_number, size_t *block_size"
-      end
-      s += ")"
-      return s
+      @headers = [] unless @headers
     end
 
+    # @private
     def boast_header(lang=C)
       s = boast_header_s(lang)
       s += ";\n"
@@ -90,29 +55,6 @@ module BOAST
       return k
     end
 
-    def close_c
-      s = ""
-      s += indent + "return #{@properties[:return]};\n" if @properties[:return]
-      decrement_indent_level
-      s += indent + "}"
-      output.puts s
-      return self
-    end
-
-    def close_fortran
-      s = ""
-      if @properties[:return] then
-        s += indent + "#{@name} = #{@properties[:return]}\n"
-        decrement_indent_level
-        s += indent + "END FUNCTION #{@name}"
-      else
-        decrement_indent_level
-        s += indent + "END SUBROUTINE #{@name}"
-      end
-      output.puts s
-      return self
-    end
-
     def pr
       open
       if @block then
@@ -127,6 +69,18 @@ module BOAST
       return decl_c if [C, CL, CUDA].include?( lang )
     end
 
+    def open
+      return open_fortran if lang==FORTRAN
+      return open_c if [C, CL, CUDA].include?( lang )
+    end
+
+    def to_s
+      return decl_c_s if [C, CL, CUDA].include?( lang )
+      return to_s_fortran if lang==FORTRAN
+    end
+
+    private
+
     def decl_fortran
       output.puts indent + "INTERFACE"
       increment_indent_level
@@ -179,9 +133,9 @@ module BOAST
       end
       s += "#{@name}("
       if parameters.first then
-        s += parameters.first.decl_c_s(@properties[:local])
+        s += parameters.first.send(:decl_c_s, @properties[:local])
         parameters[1..-1].each { |p|
-          s += ", "+p.decl_c_s(@properties[:local])
+          s += ", "+p.send(:decl_c_s, @properties[:local])
         }
       end
       s += ")"
@@ -194,16 +148,6 @@ module BOAST
       return self
     end
 
-    def open
-      return open_fortran if lang==FORTRAN
-      return open_c if [C, CL, CUDA].include?( lang )
-    end
-
-    def to_s
-      return decl_c_s if [C, CL, CUDA].include?( lang )
-      return to_s_fortran if lang==FORTRAN
-    end
-
     def to_s_fortran
       s = ""
       if @properties[:return] then
@@ -255,6 +199,67 @@ module BOAST
       return self
     end
 
+    def close_c
+      s = ""
+      s += indent + "return #{@properties[:return]};\n" if @properties[:return]
+      decrement_indent_level
+      s += indent + "}"
+      output.puts s
+      return self
+    end
+
+    def close_fortran
+      s = ""
+      if @properties[:return] then
+        s += indent + "#{@name} = #{@properties[:return]}\n"
+        decrement_indent_level
+        s += indent + "END FUNCTION #{@name}"
+      else
+        decrement_indent_level
+        s += indent + "END SUBROUTINE #{@name}"
+      end
+      output.puts s
+      return self
+    end
+
+    def boast_header_s( lang=C )
+      s = ""
+      headers.each { |h|
+        s += "#include <#{h}>\n"
+      }
+      if 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.boast_header(lang)
+        parameters[1..-1].each { |p|
+          s += ", "
+          s += p.boast_header(lang)
+        }
+      end
+      if lang == CUDA then
+        s += ", " if parameters.first
+        s += "size_t *block_number, size_t *block_size"
+      end
+      s += ")"
+      return s
+    end
+
   end
 
 end

data/lib/BOAST/Language/Slice.rb

@@ -13,6 +13,22 @@ module BOAST
       @slices = slices
     end
 
+    def to_s
+      return to_s_fortran if lang == FORTRAN
+      return to_s_c if [C, CL, CUDA].include?( lang )
+    end
+
+    def pr
+      s=""
+      s += indent
+      s += to_s
+      s += ";" if [C, CL, CUDA].include?( lang )
+      output.puts s
+      return self
+    end
+
+    private
+
     def to_s_c
       s = "#{@source}["
       dims = @source.dimension.reverse
@@ -67,20 +83,6 @@ module BOAST
       return "#{source}(#{slices_to_fortran.join(",")})"
     end
 
-    def to_s
-      return to_s_fortran if lang == FORTRAN
-      return to_s_c if [C, CL, CUDA].include?( lang )
-    end
-
-    def pr
-      s=""
-      s += indent
-      s += to_s
-      s += ";" if [C, CL, CUDA].include?( lang )
-      output.puts s
-      return self
-    end
-
   end
 
   class Variable

data/lib/BOAST/Language/State.rb

@@ -1,91 +1,162 @@
 module BOAST
 
-  def self.state_accessor(*args)
-    args.each { |arg|
-      s = <<EOF
-  def #{arg}=(val)
-    @@#{arg} = val
+  EXTENDED = []
+  private_constant :EXTENDED
+
+  def self.included(base)
+    EXTENDED.each { |m|
+      base.send(:include, m)
+    }
+  end
+
+  # Generates setters and getters for the specified state
+  # @param [Symbol] state
+  # @!macro [attach] state_accessor
+  #   @!method $1
+  #     @scope class
+  #     @return the BOAST *$1* state
+  #   @!method $1=( val )
+  #     @scope class
+  #     Sets *$1* state to a new value
+  #     @param val the new value of *$1* state
+  #     @return the new +$1+ state
+  #   @!method get_$1
+  #     @scope class
+  #     @return the *$1* state
+  #   @!method set_$1( val )
+  #     @scope class
+  #     Sets *$1* state to a new value
+  #     @param val the new value of *$1* state
+  #     @return the new *$1* state
+  def self.state_accessor(state)
+    s = <<EOF
+  module_function
+
+  def #{state}=(val)
+    @@#{state} = val
   end
-  module_function :#{arg}=
-  def #{arg}
-    @@#{arg}
+
+  def #{state}
+    @@#{state}
   end
-  module_function :#{arg}
-  def set_#{arg}(val)
-    @@#{arg} = val
+
+  def set_#{state}(val)
+    @@#{state} = val
   end
-  module_function :set_#{arg}
-  def get_#{arg}
-    @@#{arg}
+
+  def get_#{state}
+    @@#{state}
   end
-  module_function :get_#{arg}
 EOF
-      eval s
-    }
+    eval s
   end
 
-  def self.boolean_state_accessor(*args)
-    self.state_accessor(*args)
-    args.each { |arg|
-      s = <<EOF
-  def #{arg}?
-    !!@@#{arg}
+  # Generates setters and getters for the specified boolean state
+  # @param [Symbol] state
+  # @!macro [attach] boolean_state_accessor
+  #   @!method $1?
+  #     @scope class
+  #     @return the boolean evaluation of the *$1* state
+  #   @!parse state_accessor $1
+  def self.boolean_state_accessor(state)
+    state_accessor(state)
+    s = <<EOF
+  module_function
+
+  def #{state}?
+    !!@@#{state}
   end
-  module_function :#{arg}?
 EOF
-      eval s
-    }
+    eval s
   end
 
-  def self.default_state_getter(arg, default, get_env_string=nil, env = arg.upcase)
+
+  # Generates an initializer for the specified state using default value or environment variable. Calls this initializer.
+  # @param [Symbol] state
+  # @param [Object] default default value
+  # @param [String] get_env_string if specified, an escaped string that can be evaluated. the envs variable can be used in the string to obtain what the corresponding environment variable was. Example: '"const_get(#{ envs })"'
+  # @param [Symbol] env name of the corresponding environment variable
+  # @!macro [attach] default_state_getter
+  #   @!method get_default_$1
+  #     @scope class
+  #     @private
+  def self.default_state_getter(state, default, get_env_string=nil, env = state.upcase)
     envs = "ENV['#{env}']"
     s = <<EOF
-  def get_default_#{arg}
-    #{arg} = @@boast_config[#{arg.inspect}]
-    #{arg} = #{default.inspect} unless #{arg}
-    #{arg} = #{get_env_string ? eval( "#{get_env_string}" ) : "YAML::load(#{envs})" } if #{envs}
-    return #{arg}
+  module_function
+
+  def get_default_#{state}
+    #{state} = @@boast_config[#{state.inspect}]
+    #{state} = #{default.inspect} unless #{state}
+    #{state} = #{get_env_string ? eval( "#{get_env_string}" ) : "YAML::load(#{envs})" } if #{envs}
+    return #{state}
   end
-  module_function :get_default_#{arg}
-  @@#{arg} = get_default_#{arg}
+
+  @@#{state} = get_default_#{state}
 EOF
     eval s
   end
 
+  # Implements private setters and getters interface for BOAST states.
+  # @private
   module PrivateStateAccessor
 
-    def self.private_state_accessor(*args)
-      args.each { |arg|
-        s = <<EOF
     private
-    def #{arg}=(val)
-      BOAST::#{arg}= val
+
+    # Generates private setters and getters for the specified state
+    # @param [Symbol] state
+    # @!macro [attach] private_state_accessor
+    #   @!method $1
+    #     @return the BOAST *$1* state
+    #     @private
+    #   @!method $1=( val )
+    #     Sets *$1* state to a new value
+    #     @param val the new value of *$1* state
+    #     @return the new +$1+ state
+    #     @private
+    #   @!method get_$1
+    #     @return the *$1* state
+    #     @private
+    #   @!method set_$1( val )
+    #     Sets *$1* state to a new value
+    #     @param val the new value of *$1* state
+    #     @return the new *$1* state
+    #     @private
+    def self.private_state_accessor(state)
+      s = <<EOF
+    private
+    def #{state}=(val)
+      BOAST::set_#{state}(val)
     end
-    def #{arg}
-      BOAST::#{arg}
+    def #{state}
+      BOAST::get_#{state}
     end
-    def set_#{arg}(val)
-      BOAST::set_#{arg}(val)
+    def set_#{state}(val)
+      BOAST::set_#{state}(val)
     end
-    def get_#{arg}
-      BOAST::get_#{arg}
+    def get_#{state}
+      BOAST::get_#{state}
     end
 EOF
-        eval s
-      }
+      eval s
     end
   
-    def self.private_boolean_state_accessor(*args)
-      self.private_state_accessor(*args)
-      args.each { |arg|
-        s = <<EOF
+    # Generates private setters and getters for the specified boolean state
+    # @param [Symbol] state
+    # @!macro [attach] private_boolean_state_accessor
+    #   @!method $1?
+    #     @return the boolean evaluation of the *$1* state
+    #     @private
+    #   @!parse private_state_accessor $1
+    def self.private_boolean_state_accessor(state)
+      self.private_state_accessor(state)
+      s = <<EOF
     private
-    def #{arg}?
-      BOAST::#{arg}?
+    def #{state}?
+      BOAST::#{state}?
     end
 EOF
-        eval s
-      }
+      eval s
     end
 
   end