module BOAST::OpenMP

Private Class Methods

functorize(klass) click to toggle source
# File lib/BOAST/Language/OpenMP.rb, line 121
    def self.functorize(klass)
      name = klass.name.split('::').last
      s = <<EOF
    def #{name}(*args,&block)
       #{name}::new(*args,&block)
    end

    module_function :#{name}
EOF
      eval s
    end
register_openmp_compound_construct( c1, c2, options = {} ) click to toggle source

@!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
# File lib/BOAST/Language/OpenMP.rb, line 260
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,
                                              options[:no_end_clauses] ? [] : (c1.get_end_clauses + c2.get_end_clauses).uniq,
                                              :fortran_name => "#{c1.fortran_name} #{c2.fortran_name}",
                                              :block => options[:block] )
end
register_openmp_construct( name, c_name, open_clauses, end_clauses = [], options = {} ) click to toggle source

@!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
# File lib/BOAST/Language/OpenMP.rb, line 183
    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]
      s = <<EOF
    class #{name} < OpenMPControlStructure

      def self.name
        return "#{name}"
      end

      def self.c_name
        return "#{c_name}"
      end

      def self.fortran_name
        return "#{fortran_name}"
      end

      def self.block
        return #{options[:block] ? "true" : "false"}
      end

      def get_c_strings
        return { :begin => '"#pragma omp #{c_name} #{ open_clauses.length + end_clauses.length > 0 ? "\#{c}" : "" }#{ options[:block] ? "\\n{" : "" }"',
EOF
      if options[:c_end] then
        s << <<EOF
                 :end => '"#pragma omp end #{c_name}"' }
EOF
      else
        s << <<EOF
                 :end => '"#{ options[:block] ? "}" : "" }"' }
EOF
      end
        s << <<EOF
      end

      def get_fortran_strings
        return { :begin => '"!$omp #{fortran_name}#{ open_clauses.length > 0 ? " \#{c}" : "" }#{ options[:fortran_block] ? "(" : "" }"',
EOF
      if options[:fortran_no_end] then
        s << <<EOF
                 :end => '"#{ options[:fortran_block] ? ")" : "" }"' }
EOF
      else
        s << <<EOF
                 :end => '"!$omp end #{fortran_name} #{ end_clauses.length > 0 ? "\#{c}" : "" }"' }
EOF
      end
        s << <<EOF
      end

      def self.get_open_clauses
        return [ #{open_clauses.collect { |c| ":#{c}" }.join(",\n                 ")} ]
      end

      def self.get_end_clauses
        return [ #{end_clauses.collect { |c| ":#{c}" }.join(",\n                 ")} ]
      end

      def get_open_clauses
        return #{name}.get_open_clauses
      end

      def get_end_clauses
        return #{name}.get_end_clauses
      end

    end
EOF
      eval s
    end