BOAST 1.2.2 → 1.3.0

data/lib/BOAST/Language/FuncCall.rb

@@ -1,5 +1,6 @@
 module BOAST
 
+  # @!parse module Functors; functorize FuncCall; end
   class FuncCall
     include PrivateStateAccessor
     include Arithmetic
@@ -52,6 +53,8 @@ module BOAST
       s += "#{func_name}(#{@args.join(", ")})"
     end
 
+    private :to_s_fortran, :to_s_c
+
     def pr
       s=""
       s += indent
@@ -62,4 +65,8 @@ module BOAST
     end
   end
 
+  module Functors
+    alias Call FuncCall
+  end
+
 end

data/lib/BOAST/Language/Functors.rb

@@ -1,34 +1,71 @@
 module BOAST
-  
-  module_function
-  def functorize(klass)
-    name = klass.name.split('::').last
-    s = <<EOF
-  def #{name}(*args,&block)
-     #{name}::new(*args,&block)
+
+  module Functors
   end
 
-  module_function :#{name}
-EOF
-    eval s
+  module VarFunctors
   end
 
-  def var_functorize(klass)
-    name = klass.name.split('::').last
-    s = <<EOF
-  def #{name}(*args,&block)
-     Variable::new(args[0],#{name},*args[1..-1], &block)
+  extend Functors
+
+  EXTENDED.push Functors
+
+  extend VarFunctors
+
+  EXTENDED.push VarFunctors
+
+
+  module Functors
+
+    module_function
+
+    # Creates a wrapper for klass new method
+    # @param [Class] klass class to turn into a functor.
+    # @private
+    # @!macro [attach] functorize
+    #   @!method $1
+    #   Creates a new $1 object, arguments are passed to the *new* method of $1. (see {$1#initialize}).
+    def functorize(klass)
+      name = klass.name.split('::').last
+      s = <<EOF
+      def #{name}(*args,&block)
+        #{name}::new(*args,&block)
+      end
+EOF
+      class_eval s
+    end
+
   end
 
-  module_function :#{name}
+  module VarFunctors 
+
+    module_function
+
+    # Creates a functor to create a Variable of type klass
+    # @param [DataType] klass DataType to turn into a functor and add it to the VarFunctors module.
+    # @private
+    # @!macro [attach] var_functorize
+    #   @!method $1(name, *args, &block)
+    #   Creates a new Variable of type $1.
+    #   @param [#to_s] name name of the Variable
+    #   @param [Object] args parameters to use when creating a Variable
+    #   @param [Block] block block of code will be forwarded
+    def var_functorize(klass)
+      name = klass.name.split('::').last
+      s = <<EOF
+      def #{name}(*args,&block)
+        Variable::new(args[0],#{name},*args[1..-1], &block)
+      end
 EOF
-    eval s
+      class_eval s
+    end
+
   end
 
   module Functor
 
     def self.extended(mod)
-      eval "#{mod.name.split('::')[-2]}::functorize(mod)"
+      BOAST::Functors::functorize(mod)
     end
 
   end
@@ -36,7 +73,7 @@ EOF
   module VarFunctor
 
     def self.extended(mod)
-      eval "#{mod.name.split('::')[-2]}::var_functorize(mod)"
+      BOAST::VarFunctors::var_functorize(mod)
     end
 
   end

data/lib/BOAST/Language/If.rb

@@ -1,5 +1,6 @@
 module BOAST
 
+  # @!parse module Functors; functorize If; end
   class If < ControlStructure
 
     attr_reader :conditions
@@ -35,6 +36,8 @@ module BOAST
                :end => '"end if"' }
     end
 
+    private :get_c_strings, :get_fortran_strings
+
     alias get_cl_strings get_c_strings
     alias get_cuda_strings get_c_strings
 

data/lib/BOAST/Language/Index.rb

@@ -58,6 +58,17 @@ module BOAST
       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_fortran
       s = ""
       s += "#{@source}(#{@indexes.join(", ")})"
@@ -155,15 +166,6 @@ module BOAST
       return s
     end
 
-    def pr
-      s=""
-      s += indent
-      s += to_s
-      s += ";" if [C, CL, CUDA].include?( lang )
-      output.puts s
-      return self
-    end
-
   end
 
 end

data/lib/BOAST/Language/Intrinsics.rb

@@ -28,9 +28,11 @@ module BOAST
   class IntrinsicsError < Error
   end
 
+  # @private
   class InternalIntrinsicsError < Error
   end
 
+  # @private
   module Intrinsics
     extend PrivateStateAccessor
     INTRINSICS = Hash::new { |h, k| h[k] = Hash::new { |h2, k2| h2[k2] = {} } }

data/lib/BOAST/Language/OpenMP.rb

@@ -118,8 +118,7 @@ EOF
 
     end
 
-    module_function
-    def functorize(klass)
+    def self.functorize(klass)
       name = klass.name.split('::').last
       s = <<EOF
     def #{name}(*args,&block)
@@ -130,10 +129,14 @@ EOF
 EOF
       eval s
     end
- 
+
     class OpenMPControlStructure < ControlStructure
       include OpenMP::Pragma
 
+      def self.inherited(child)
+        OpenMP.send(:functorize,child)
+      end
+
       def get_strings
         return { C => get_c_strings,
                  FORTRAN => get_fortran_strings }
@@ -172,6 +175,10 @@ EOF
      
     end
 
+    # @!macro [attach] register_openmp_construct
+    #   @!method $1(options = {}, &block)
+    #   Creates an OpenMP construct that correspond to the "$2" C OpenMP construct.
+    #   @param [Hash] options OpenMP clause and their values. See OpenMP documentation
     def self.register_openmp_construct( name, c_name, open_clauses, end_clauses = [], options = {} )
       fortran_name = c_name
       fortran_name = options[:fortran_name] if options[:fortran_name]
@@ -245,6 +252,10 @@ EOF
       eval s
     end
 
+    # @!macro [attach] register_openmp_compound_construct
+    #   @!method $1$2(options={}, &block)
+    #   Creates an OpenMP construct that correspond to the "$1#c_name $2#c_name" C OpenMP construct.
+    #   @param [Hash] options OpenMP clause and their values. See OpenMP documentation
     def self.register_openmp_compound_construct( c1, c2, options = {} )
       register_openmp_construct( c1.name+c2.name, "#{c1.c_name} #{c2.c_name}",
                                                   (c1.get_open_clauses + c2.get_open_clauses).uniq,
@@ -253,7 +264,13 @@ EOF
                                                   :block => options[:block] )
     end
 
-    register_openmp_construct( :Parallel, "parallel",
+    class << self
+      private :register_openmp_construct
+      private :register_openmp_compound_construct
+      private :functorize
+    end
+
+    register_openmp_construct( "Parallel", "parallel",
                                           [ :if,
                                             :num_threads,
                                             :default,
@@ -266,7 +283,7 @@ EOF
                                           [],
                                           :block => true )
 
-    register_openmp_construct( :For, "for",
+    register_openmp_construct( "For", "for",
                                      [ :private,
                                        :firstprivate,
                                        :lastprivate,
@@ -277,7 +294,7 @@ EOF
                                      [ :nowait ],
                                      :fortran_name => "do" )
 
-    register_openmp_construct( :Sections, "sections",
+    register_openmp_construct( "Sections", "sections",
                                           [ :private,
                                             :firstprivate,
                                             :lastprivate,
@@ -285,18 +302,18 @@ EOF
                                           [ :nowait ],
                                           :block => true )
 
-    register_openmp_construct( :Section, "section", [], [],
-                                         :block => true,
-                                         :fortran_no_end => true )
+    register_openmp_construct( "Section", "section", [], [],
+                                          :block => true,
+                                          :fortran_no_end => true )
 
-    register_openmp_construct( :Single, "single",
+    register_openmp_construct( "Single", "single",
                                         [ :private,
                                           :firstprivate ],
                                         [ :copyprivate,
                                           :nowait ],
                                         :block => true )
 
-    register_openmp_construct( :Simd, "simd",
+    register_openmp_construct( "Simd", "simd",
                                       [ :safelen,
                                         :linear,
                                         :aligned,
@@ -305,7 +322,7 @@ EOF
                                         :reduction,
                                         :collapse ] )
 
-    register_openmp_construct( :DeclareSimd, "declare simd",
+    register_openmp_construct( "DeclareSimd", "declare simd",
                                              [ :simdlen,
                                                :linear,
                                                :aligned,
@@ -315,21 +332,21 @@ EOF
 
     register_openmp_compound_construct( For, Simd )
 
-    register_openmp_construct( :TargetData, "target data",
+    register_openmp_construct( "TargetData", "target data",
                                             [ :device,
                                               :map,
                                               :if ],
                                             [],
                                             :block => true )
 
-    register_openmp_construct( :Target, "target",
+    register_openmp_construct( "Target", "target",
                                         [ :device,
                                           :map,
                                           :if ],
                                         [],
                                         :block => true )
 
-    register_openmp_construct( :TargetUpdate, "target update",
+    register_openmp_construct( "TargetUpdate", "target update",
                                               [ :to,
                                                 :from,
                                                 :device,
@@ -337,14 +354,14 @@ EOF
                                               [],
                                               :fortran_no_end => true )
 
-    register_openmp_construct( :DeclareTarget, "declare target",
+    register_openmp_construct( "DeclareTarget", "declare target",
                                                [],
                                                [],
                                                :c_end => true,
                                                :fortran_no_end => true,
                                                :fortran_block => true )
 
-    register_openmp_construct( :Teams, "teams",
+    register_openmp_construct( "Teams", "teams",
                                        [ :num_teams,
                                          :thread_limit,
                                          :default,
@@ -355,7 +372,7 @@ EOF
                                        [],
                                        :block => true )
 
-    register_openmp_construct( :Distribute, "distribute",
+    register_openmp_construct( "Distribute", "distribute",
                                             [ :private,
                                               :firstprivate,
                                               :collapse,
@@ -391,7 +408,7 @@ EOF
 
     register_openmp_compound_construct( Target, TeamsDistributeParallelForSimd )
 
-    register_openmp_construct( :Task, "task",
+    register_openmp_construct( "Task", "task",
                                       [ :if,
                                         :final,
                                         :untied,
@@ -404,47 +421,47 @@ EOF
                                       [],
                                       :block => true )
 
-    register_openmp_construct( :Taskyield, "taskyield", [], [], :fortran_no_end => true )
+    register_openmp_construct( "Taskyield", "taskyield", [], [], :fortran_no_end => true )
 
-    register_openmp_construct( :Master, "master", [], [], :block => true )
+    register_openmp_construct( "Master", "master", [], [], :block => true )
 
-    register_openmp_construct( :Critical, "critical", [:name], [:name], :block => true )
+    register_openmp_construct( "Critical", "critical", [:name], [:name], :block => true )
 
-    register_openmp_construct( :Barrier, "barrier", [], [], :fortran_no_end => true )
+    register_openmp_construct( "Barrier", "barrier", [], [], :fortran_no_end => true )
 
-    register_openmp_construct( :Taskwait, "taskwait", [], [], :fortran_no_end => true )
+    register_openmp_construct( "Taskwait", "taskwait", [], [], :fortran_no_end => true )
 
-    register_openmp_construct( :Taskgroup, "taskgroup", [], [], :block => true )
+    register_openmp_construct( "Taskgroup", "taskgroup", [], [], :block => true )
 
-    register_openmp_construct( :AtomicRead, "atomic read", [:seq_cst], [] )
+    register_openmp_construct( "AtomicRead", "atomic read", [:seq_cst], [] )
 
-    register_openmp_construct( :AtomicWrite, "atomic write", [:seq_cst], [] )
+    register_openmp_construct( "AtomicWrite", "atomic write", [:seq_cst], [] )
 
-    register_openmp_construct( :AtomicUpdate, "atomic update", [:seq_cst], [] )
+    register_openmp_construct( "AtomicUpdate", "atomic update", [:seq_cst], [] )
 
-    register_openmp_construct( :AtomicCapture, "atomic capture", [:seq_cst], [], :block => true )
+    register_openmp_construct( "AtomicCapture", "atomic capture", [:seq_cst], [], :block => true )
 
-    register_openmp_construct( :Flush, "flush", [:flush_list], [], :fortran_no_end => true )
+    register_openmp_construct( "Flush", "flush", [:flush_list], [], :fortran_no_end => true )
 
-    register_openmp_construct( :Ordered, "ordered", [], [], :block => true )
+    register_openmp_construct( "Ordered", "ordered", [], [], :block => true )
 
-    register_openmp_construct( :CancelParallel, "cancel parallel", [:if], [], :fortran_no_end => true )
+    register_openmp_construct( "CancelParallel", "cancel parallel", [:if], [], :fortran_no_end => true )
 
-    register_openmp_construct( :CancelSections, "cancel sections", [:if], [], :fortran_no_end => true )
+    register_openmp_construct( "CancelSections", "cancel sections", [:if], [], :fortran_no_end => true )
 
-    register_openmp_construct( :CancelFor, "cancel for", [:if], [], :fortran_no_end => true )
+    register_openmp_construct( "CancelFor", "cancel for", [:if], [], :fortran_no_end => true )
 
-    register_openmp_construct( :CancelTaskgroup, "cancel taskgroup", [:if], [], :fortran_no_end => true )
+    register_openmp_construct( "CancelTaskgroup", "cancel taskgroup", [:if], [], :fortran_no_end => true )
 
-    register_openmp_construct( :CancellationPointParallel, "cancellation point parallel", [], [], :fortran_no_end => true )
+    register_openmp_construct( "CancellationPointParallel", "cancellation point parallel", [], [], :fortran_no_end => true )
 
-    register_openmp_construct( :CancellationPointSections, "cancellation point sections", [], [], :fortran_no_end => true )
+    register_openmp_construct( "CancellationPointSections", "cancellation point sections", [], [], :fortran_no_end => true )
 
-    register_openmp_construct( :CancellationPointFor, "cancellation point for", [], [], :fortran_no_end => true )
+    register_openmp_construct( "CancellationPointFor", "cancellation point for", [], [], :fortran_no_end => true )
 
-    register_openmp_construct( :CancellationPointTaskgroup, "cancellation point taskgroup", [], [], :fortran_no_end => true )
+    register_openmp_construct( "CancellationPointTaskgroup", "cancellation point taskgroup", [], [], :fortran_no_end => true )
 
-    register_openmp_construct( :Threadprivate, "threadprivate", [:threadprivate_list], [], :fortran_no_end => true )
+    register_openmp_construct( "Threadprivate", "threadprivate", [:threadprivate_list], [], :fortran_no_end => true )
 
   end
 

data/lib/BOAST/Language/Operators.rb

@@ -304,6 +304,7 @@ module BOAST
 
   end
 
+  # @!parse module Functors; functorize Set; end
   class Set < Operator
     extend Functor
     include Intrinsics
@@ -375,6 +376,7 @@ module BOAST
 
   end
 
+  # @!parse module Functors; functorize Load; end
   class Load < Operator
     extend Functor
     include Intrinsics
@@ -439,6 +441,7 @@ module BOAST
 
   end
 
+  # @!parse module Functors; functorize MaskLoad; end
   class MaskLoad < Operator
     extend Functor
     include Intrinsics
@@ -502,6 +505,7 @@ module BOAST
 
   end
 
+  # @!parse module Functors; functorize Store; end
   class Store < Operator
     extend Functor
     include Intrinsics
@@ -555,6 +559,7 @@ module BOAST
 
   end
 
+  # @!parse module Functors; functorize MaskStore; end
   class MaskStore < Operator
     extend Functor
     include Intrinsics
@@ -615,6 +620,7 @@ module BOAST
 
   end
 
+  # @!parse module Functors; functorize FMA; end
   class FMA < Operator
     extend Functor
     include Intrinsics
@@ -685,6 +691,7 @@ module BOAST
 
   end
 
+  # @!parse module Functors; functorize FMS; end
   class FMS < Operator
     extend Functor
     include Intrinsics
@@ -756,6 +763,7 @@ module BOAST
 
   end
 
+  # @!parse module Functors; functorize Ternary; end
   class Ternary
     extend Functor
     include Arithmetic
@@ -772,23 +780,22 @@ module BOAST
       @operand3 = z
     end
 
-    def op_to_var
-      op1 = @operand1.respond_to?(:to_var) ? @operand1.to_var : @operand1
-      op1 = @operand1 unless op1
-      op2 = @operand2.respond_to?(:to_var) ? @operand2.to_var : @operand2
-      op2 = @operand2 unless op2
-      op3 = @operand3.respond_to?(:to_var) ? @operand3.to_var : @operand3
-      op3 = @operand3 unless op3
-      return [op1, op2, op3]
-    end
-
-    private :op_to_var
-
     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_fortran
       op1, op2, op3 = op_to_var
       "merge(#{op2}, #{op3}, #{op1})"
@@ -799,13 +806,14 @@ module BOAST
       "(#{op1} ? #{op2} : #{op3})"
     end
 
-    def pr
-      s=""
-      s += indent
-      s += to_s
-      s += ";" if [C, CL, CUDA].include?( lang )
-      output.puts s
-      return self
+    def op_to_var
+      op1 = @operand1.respond_to?(:to_var) ? @operand1.to_var : @operand1
+      op1 = @operand1 unless op1
+      op2 = @operand2.respond_to?(:to_var) ? @operand2.to_var : @operand2
+      op2 = @operand2 unless op2
+      op3 = @operand3.respond_to?(:to_var) ? @operand3.to_var : @operand3
+      op3 = @operand3 unless op3
+      return [op1, op2, op3]
     end
 
   end