BOAST 1.0.3 → 1.0.4

data/lib/BOAST/Runtime/CompiledRuntime.rb

@@ -0,0 +1,398 @@
+require 'stringio'
+require 'rake'
+require 'tempfile'
+require 'rbconfig'
+require 'systemu'
+require 'pathname'
+require 'os'
+
+class Dir
+  module Tmpname
+    module_function
+    def make_tmpname(prefix_suffix, n)
+      case prefix_suffix
+      when String
+        prefix = prefix_suffix
+        suffix = ""
+      when Array
+        prefix = prefix_suffix[0]
+        suffix = prefix_suffix[1]
+      else
+        raise ArgumentError, "unexpected prefix_suffix: #{prefix_suffix.inspect}"
+      end
+      t = Time.now.strftime("%Y%m%d")
+      path = "#{prefix}#{t}_#{$$}_#{rand(0x100000000).to_s(36)}"
+      path << "_#{n}" if n
+      path << suffix
+    end
+  end
+end
+
+module BOAST
+
+  module CompiledRuntime
+    @@extensions = {
+      C => ".c",
+      CUDA => ".cu",
+      FORTRAN => ".f90"
+    }
+
+    def base_name
+      return File::split(@marker.path)[1]
+    end
+
+    def module_name
+      return "Mod_" + base_name#.gsub("-","_")
+    end
+
+    def directory
+      return File::split(@marker.path)[0]
+    end
+
+    def module_file_base_name
+      return "Mod_" + base_name
+    end
+
+    def module_file_base_path
+      return "#{directory}/#{module_file_base_name}"
+    end
+
+    def module_file_path
+      return "#{module_file_base_path}.#{RbConfig::CONFIG["DLEXT"]}"
+    end
+
+    def module_file_source
+      return module_file_base_path + ".c"
+    end
+
+    def module_file_object
+      return "#{module_file_base_path}.#{RbConfig::CONFIG["OBJEXT"]}"
+    end
+
+    def base_path
+      return "#{directory}/#{base_name}"
+    end
+
+    def library_source
+      return base_path + @@extensions[@lang]
+    end
+
+    def library_object
+      return "#{base_path}.#{RbConfig::CONFIG["OBJEXT"]}"
+    end
+
+    def library_path
+      return "#{base_path}.#{RbConfig::CONFIG["DLEXT"]}"
+    end
+
+    def target
+      return module_file_path
+    end
+
+    def target_depends
+      return [ module_file_object, library_object ]
+    end
+
+    def save_binary
+      f = File::open(library_object,"rb")
+      @binary = StringIO::new
+      @binary.write( f.read )
+      f.close
+    end
+
+    def create_targets( linker, ldshared, ldflags, kernel_files)
+      file target => target_depends do
+        #puts "#{linker} #{ldshared} -o #{target} #{target_depends.join(" ")} #{(kernel_files.collect {|f| f.path}).join(" ")} #{ldflags}"
+        sh "#{linker} #{ldshared} -o #{target} #{target_depends.join(" ")} #{(kernel_files.collect {|f| f.path}).join(" ")} #{ldflags}"
+      end
+      Rake::Task[target].invoke
+    end
+
+    def method_name
+      return @procedure.name
+    end
+
+    def get_sub_kernels
+      kernel_files = []
+      @kernels.each { |kernel|
+        kernel_file = Tempfile::new([kernel.procedure.name,".#{RbConfig::CONFIG["OBJEXT"]}"])
+        kernel.binary.rewind
+        kernel_file.write( kernel.binary.read )
+        kernel_file.close
+        kernel_files.push(kernel_file)
+      }
+      return kernel_files
+    end
+
+    def create_library_source
+      f = File::open(library_source,"w+")
+      previous_lang = get_lang
+      previous_output = get_output
+      set_output(f)
+      set_lang(@lang)
+
+      fill_library_source
+
+      if debug_source? then
+        f.rewind
+        puts f.read
+      end
+      set_output(previous_output)
+      set_lang(previous_lang)
+      f.close
+    end
+
+    def fill_module_header
+      get_output.print <<EOF
+#include "ruby.h"
+#include <inttypes.h>
+#ifdef HAVE_NARRAY_H
+#include "narray.h"
+#endif
+EOF
+    end
+
+    def fill_module_preamble
+      get_output.print <<EOF
+VALUE #{module_name} = Qnil;
+void Init_#{module_name}();
+VALUE method_run(int _boast_argc, VALUE *_boast_argv, VALUE _boast_self);
+void Init_#{module_name}() {
+  #{module_name} = rb_define_module("#{module_name}");
+  rb_define_method(#{module_name}, "run", method_run, -1);
+}
+EOF
+    end
+
+    def fill_check_args
+      get_output.print <<EOF
+  VALUE _boast_rb_opts;
+  if( _boast_argc < #{@procedure.parameters.length} || _boast_argc > #{@procedure.parameters.length + 1} )
+    rb_raise(rb_eArgError, "Wrong number of arguments for #{@procedure.name} (%d for #{@procedure.parameters.length})!", _boast_argc);
+  _boast_rb_opts = Qnil;
+  if( _boast_argc == #{@procedure.parameters.length + 1} ) {
+    _boast_rb_opts = _boast_argv[_boast_argc -1];
+    if ( _boast_rb_opts != Qnil ) {
+      if (TYPE(_boast_rb_opts) != T_HASH)
+        rb_raise(rb_eArgError, "Options should be passed as a hash");
+    }
+  }
+EOF
+    end
+
+    def fill_decl_module_params
+      set_decl_module(true)
+      @procedure.parameters.each { |param|
+        param_copy = param.copy
+        param_copy.constant = nil
+        param_copy.direction = nil
+        param_copy.decl
+      }
+      get_output.puts "  #{@procedure.properties[:return].type.decl} _boast_ret;" if @procedure.properties[:return]
+      get_output.puts "  VALUE _boast_stats = rb_hash_new();"
+      get_output.puts "  VALUE _boast_rb_ptr = Qnil;"
+      refs = false
+      @procedure.parameters.each_with_index do |param,i|
+        refs = true if param.scalar_output?
+      end
+      if refs then
+        get_output.puts "  VALUE _boast_refs = rb_hash_new();"
+        get_output.puts "  rb_hash_aset(_boast_stats,ID2SYM(rb_intern(\"reference_return\")),_boast_refs);"
+      end
+      set_decl_module(false)
+    end
+
+    def copy_scalar_param_from_ruby( param, ruby_param )
+      case param.type
+      when Int
+        (param === FuncCall::new("NUM2INT", ruby_param)).pr if param.type.size == 4
+        (param === FuncCall::new("NUM2LONG", ruby_param)).pr if param.type.size == 8
+      when Real
+        (param === FuncCall::new("NUM2DBL", ruby_param)).pr
+      end
+    end
+
+    def copy_array_param_from_ruby( param, ruby_param )
+      rb_ptr = Variable::new("_boast_rb_ptr", CustomType, :type_name => "VALUE")
+      (rb_ptr === ruby_param).pr
+      get_output.print <<EOF
+  if (TYPE(_boast_rb_ptr) == T_STRING) {
+    #{param} = (void *) RSTRING_PTR(_boast_rb_ptr);
+  } else if ( IsNArray(_boast_rb_ptr) ) {
+    struct NARRAY *_boast_n_ary;
+    Data_Get_Struct(_boast_rb_ptr, struct NARRAY, _boast_n_ary);
+    #{param} = (void *) _boast_n_ary->ptr;
+  } else {
+    rb_raise(rb_eArgError, "Wrong type of argument for %s, expecting array!", "#{param}");
+  }
+EOF
+    end
+
+    def get_params_value
+      argc = @procedure.parameters.length
+      argv = Variable::new("_boast_argv", CustomType, :type_name => "VALUE", :dimension => [ Dimension::new(0,argc-1) ] )
+      rb_ptr = Variable::new("_boast_rb_ptr", CustomType, :type_name => "VALUE")
+      set_decl_module(true)
+      @procedure.parameters.each_index do |i|
+        param = @procedure.parameters[i]
+        if not param.dimension then
+          copy_scalar_param_from_ruby(param, argv[i])
+        else
+          copy_array_param_from_ruby(param, argv[i])
+        end
+      end
+      set_decl_module(false)
+    end
+
+    def create_procedure_call
+      get_output.print "  _boast_ret = " if @procedure.properties[:return]
+      get_output.print " #{method_name}( "
+      get_output.print create_procedure_call_parameters.join(", ")
+      get_output.puts " );"
+    end
+
+    def copy_scalar_param_to_ruby(param, ruby_param)
+      if param.scalar_output? then
+        case param.type
+        when Int
+          get_output.puts "  rb_hash_aset(_boast_refs, ID2SYM(rb_intern(\"#{param}\")),rb_int_new((long long)#{param}));" if param.type.signed?
+          get_output.puts "  rb_hash_aset(_boast_refs, ID2SYM(rb_intern(\"#{param}\")),rb_int_new((unsigned long long)#{param}));" if not param.type.signed?
+        when Real
+          get_output.puts "  rb_hash_aset(_boast_refs, ID2SYM(rb_intern(\"#{param}\")),rb_float_new((double)#{param}));"
+        end
+      end
+    end
+
+    def copy_array_param_to_ruby(param, ruby_param)
+    end
+
+    def get_results
+      argc = @procedure.parameters.length
+      argv = Variable::new("_boast_argv", CustomType, :type_name => "VALUE", :dimension => [ Dimension::new(0,argc-1) ] )
+      rb_ptr = Variable::new("_boast_rb_ptr", CustomType, :type_name => "VALUE")
+      set_decl_module(true)
+      @procedure.parameters.each_index do |i|
+        param = @procedure.parameters[i]
+        if not param.dimension then
+          copy_scalar_param_to_ruby(param, argv[i])
+        else
+          copy_array_param_to_ruby(param, argv[i])
+        end
+      end
+      set_decl_module(false)
+    end
+
+    def store_results
+      if @procedure.properties[:return] then
+        type_ret = @procedure.properties[:return].type
+        get_output.puts "  rb_hash_aset(_boast_stats,ID2SYM(rb_intern(\"return\")),rb_int_new((long long)_boast_ret));" if type_ret.kind_of?(Int) and type_ret.signed
+        get_output.puts "  rb_hash_aset(_boast_stats,ID2SYM(rb_intern(\"return\")),rb_int_new((unsigned long long)_boast_ret));" if type_ret.kind_of?(Int) and not type_ret.signed
+        get_output.puts "  rb_hash_aset(_boast_stats,ID2SYM(rb_intern(\"return\")),rb_float_new((double)_boast_ret));" if type_ret.kind_of?(Real)
+      end
+    end
+
+    def fill_module_file_source
+      fill_module_header
+      @probes.map(&:header)
+      @procedure.boast_header(@lang)
+
+      fill_module_preamble
+
+      set_transition("VALUE", "VALUE", :default,  CustomType::new(:type_name => "VALUE"))
+      get_output.puts "VALUE method_run(int _boast_argc, VALUE *_boast_argv, VALUE _boast_self) {"
+      increment_indent_level
+
+      fill_check_args
+
+      fill_decl_module_params
+
+      @probes.reverse.map(&:decl)
+
+      get_params_value
+
+      @probes.map(&:configure)
+
+      @probes.reverse.map(&:start)
+
+      create_procedure_call
+
+      @probes.map(&:stop)
+
+      @probes.map(&:compute)
+
+      get_results
+
+      store_results
+
+      get_output.puts "  return _boast_stats;"
+      decrement_indent_level
+      get_output.puts "}"
+    end
+
+    def create_module_file_source
+      f = File::open(module_file_source, "w+")
+      previous_lang = get_lang
+      previous_output = get_output
+      set_output(f)
+      set_lang(C)
+
+      fill_module_file_source
+
+      if debug_source? then
+        f.rewind
+        puts f.read
+      end
+      set_output(previous_output)
+      set_lang(previous_lang)
+      f.close
+    end
+
+    def create_sources
+      create_library_source
+      create_module_file_source
+    end
+
+    def load_module
+      require module_file_path
+    end
+
+    def target_sources
+      return [ module_file_source, library_source ]
+    end
+
+    def cleanup(kernel_files)
+      ([target] + target_depends + target_sources).each { |fn|
+        File::unlink(fn)
+      }
+      kernel_files.each { |f|
+        f.unlink
+      }
+    end
+
+    def build(options={})
+      compiler_options = BOAST::get_compiler_options
+      compiler_options.update(options)
+      linker, ldshared, ldflags = setup_compilers(compiler_options)
+
+      @marker = Tempfile::new([@procedure.name,""])
+
+      kernel_files = get_sub_kernels
+
+      create_sources
+
+      create_targets(linker, ldshared, ldflags, kernel_files)
+
+      save_binary
+
+      load_module
+
+      cleanup(kernel_files)
+
+      eval "self.extend(#{module_name})"
+
+      return self
+    end
+
+  end
+
+end

data/lib/BOAST/Runtime/Compilers.rb

@@ -0,0 +1,205 @@
+require 'rake'
+require 'rbconfig'
+require 'systemu'
+require 'os'
+
+module BOAST
+
+  module Compilers
+    include Rake::DSL
+
+    def get_openmp_flags(compiler)
+      openmp_flags = BOAST::get_openmp_flags[compiler]
+      if not openmp_flags then
+        keys = BOAST::get_openmp_flags.keys
+        keys.each { |k|
+          openmp_flags = BOAST::get_openmp_flags[k] if compiler.match(k)
+        }
+      end
+      return openmp_flags
+    end
+
+    def get_includes(narray_path)
+      includes = "-I#{RbConfig::CONFIG["archdir"]}"
+      includes += " -I#{RbConfig::CONFIG["rubyhdrdir"]} -I#{RbConfig::CONFIG["rubyhdrdir"]}/#{RbConfig::CONFIG["arch"]}"
+      includes += " -I#{RbConfig::CONFIG["rubyarchhdrdir"]}" if RbConfig::CONFIG["rubyarchhdrdir"]
+      includes += " -I#{narray_path}" if narray_path
+      return includes
+    end
+
+    def get_narray_path
+      narray_path = nil
+      begin
+        spec = Gem::Specification::find_by_name('narray')
+        narray_path = spec.full_gem_path
+      rescue Gem::LoadError => e
+      rescue NoMethodError => e
+        spec = Gem::available?('narray')
+        if spec then
+          require 'narray' 
+          narray_path = Gem.loaded_specs['narray'].full_gem_path
+        end
+      end
+    end
+
+    def setup_c_compiler(options, includes, narray_path, runner)
+      c_mppa_compiler = "k1-gcc"
+      c_compiler = options[:CC]
+      cflags = options[:CFLAGS]
+      cflags += " -fPIC #{includes}"
+      cflags += " -DHAVE_NARRAY_H" if narray_path
+      cflags += " -I/usr/local/k1tools/include" if @architecture == MPPA
+      objext = RbConfig::CONFIG["OBJEXT"]
+      if options[:openmp] and @lang == C then
+          openmp_cflags = get_openmp_flags(c_compiler)
+          raise "unkwown openmp flags for: #{c_compiler}" if not openmp_cflags
+          cflags += " #{openmp_cflags}"
+      end
+
+      rule ".#{objext}" => '.c' do |t|
+        c_call_string = "#{c_compiler} #{cflags} -c -o #{t.name} #{t.source}"
+        runner.call(t, c_call_string)
+      end
+
+      rule ".#{objext}io" => ".cio" do |t|
+        c_call_string = "#{c_mppa_compiler} -mcore=k1io -mos=rtems"
+        c_call_string += " -mboard=developer -x c -c -o #{t.name} #{t.source}"
+        runner.call(t, c_call_string)
+      end
+
+      rule ".#{objext}comp" => ".ccomp" do |t|
+        c_call_string = "#{c_mppa_compiler} -mcore=k1dp -mos=nodeos"
+        c_call_string += " -mboard=developer -x c -c -o #{t.name} #{t.source}"
+        runner.call(t, c_call_string)
+      end
+    end
+
+    def setup_cxx_compiler(options, includes, runner)
+      cxx_compiler = options[:CXX]
+      cxxflags = options[:CXXFLAGS]
+      cxxflags += " -fPIC #{includes}"
+      if options[:openmp] and @lang == C then
+          openmp_cxxflags = get_openmp_flags(cxx_compiler)
+          raise "unkwown openmp flags for: #{cxx_compiler}" if not openmp_cxxflags
+          cxxflags += " #{openmp_cxxflags}"
+      end
+
+      rule ".#{RbConfig::CONFIG["OBJEXT"]}" => '.cpp' do |t|
+        cxx_call_string = "#{cxx_compiler} #{cxxflags} -c -o #{t.name} #{t.source}"
+        runner.call(t, cxx_call_string)
+      end
+    end
+
+    def setup_fortran_compiler(options, runner)
+      f_compiler = options[:FC]
+      fcflags = options[:FCFLAGS]
+      fcflags += " -fPIC"
+      fcflags += " -fno-second-underscore" if f_compiler == 'g95'
+      if options[:openmp] and @lang == FORTRAN then
+          openmp_fcflags = get_openmp_flags(f_compiler)
+          raise "unkwown openmp flags for: #{f_compiler}" if not openmp_fcflags
+          fcflags += " #{openmp_fcflags}"
+      end
+
+      rule ".#{RbConfig::CONFIG["OBJEXT"]}" => '.f90' do |t|
+        f_call_string = "#{f_compiler} #{fcflags} -c -o #{t.name} #{t.source}"
+        runner.call(t, f_call_string)
+      end
+    end
+
+    def setup_cuda_compiler(options, runner)
+      cuda_compiler = options[:NVCC]
+      cudaflags = options[:NVCCFLAGS]
+      cudaflags += " --compiler-options '-fPIC'"
+
+      rule ".#{RbConfig::CONFIG["OBJEXT"]}" => '.cu' do |t|
+        cuda_call_string = "#{cuda_compiler} #{cudaflags} -c -o #{t.name} #{t.source}"
+        runner.call(t, cuda_call_string)
+      end
+    end
+
+    def setup_linker_mppa(options, runner)
+      objext = RbConfig::CONFIG["OBJEXT"]
+      ldflags = options[:LDFLAGS]
+      board = " -mboard=developer"
+      ldflags += " -lmppaipc"
+      
+      linker = "k1-gcc"
+      
+      rule ".bincomp" => ".#{objext}comp" do |t|
+        linker_string = "#{linker} -o #{t.name} #{t.source} -mcore=k1dp #{board} -mos=nodeos #{ldflags}"
+        runner.call(t, linker_string)
+      end
+      
+      rule ".binio" => ".#{objext}io" do |t|
+        linker_string = "#{linker} -o #{t.name} #{t.source} -mcore=k1io #{board} -mos=rtems #{ldflags}"
+        runner.call(t, linker_string)
+      end
+
+    end
+
+    def setup_linker(options)
+      ldflags = options[:LDFLAGS]
+      ldflags += " -L#{RbConfig::CONFIG["libdir"]} #{RbConfig::CONFIG["LIBRUBYARG"]}"
+      ldflags += " -lrt" if not OS.mac?
+      ldflags += " -lcudart" if @lang == CUDA
+      ldflags += " -L/usr/local/k1tools/lib64 -lmppaipc -lpcie -lz -lelf -lmppa_multiloader" if @architecture == MPPA
+      ldflags += " -lmppamon -lmppabm -lm -lmppalock" if @architecture == MPPA
+      c_compiler = options[:CC]
+      c_compiler = "cc" if not c_compiler
+      linker = options[:LD]
+      linker = c_compiler if not linker
+      if options[:openmp] then
+        openmp_ldflags = get_openmp_flags(linker)
+        raise "unknown openmp flags for: #{linker}" if not openmp_ldflags
+        ldflags += " #{openmp_ldflags}"
+      end
+
+      if OS.mac? then
+        ldflags = "-Wl,-undefined,dynamic_lookup -Wl,-multiply_defined,suppress #{ldflags}"
+        ldshared = "-dynamic -bundle"
+      else
+        ldflags = "-Wl,-Bsymbolic-functions -Wl,-z,relro -rdynamic -Wl,-export-dynamic #{ldflags}"
+        ldshared = "-shared"
+      end
+
+      return [linker, ldshared, ldflags]
+    end
+
+    def setup_compilers(options = {})
+      Rake::Task::clear
+      verbose = options[:verbose]
+      verbose = get_verbose if not verbose
+      Rake::verbose(verbose)
+      Rake::FileUtilsExt.verbose_flag=verbose
+
+      narray_path = get_narray_path
+      includes = get_includes(narray_path)
+
+      runner = lambda { |t, call_string|
+        if verbose then
+          sh call_string
+        else
+          status, stdout, stderr = systemu call_string
+          if not status.success? then
+            puts stderr
+            fail "#{t.source}: compilation failed"
+          end
+          status.success?
+        end
+      }
+
+      setup_c_compiler(options, includes, narray_path, runner)
+      setup_cxx_compiler(options, includes, runner)
+      setup_fortran_compiler(options, runner)
+      setup_cuda_compiler(options, runner)
+      
+      setup_linker_mppa(options, runner) if @architecture == MPPA
+
+      return setup_linker(options)
+
+    end
+
+  end
+
+end

data/lib/BOAST/Runtime/Config.rb

@@ -0,0 +1,94 @@
+require 'yaml'
+
+module BOAST
+
+  @@compiler_default_options = {
+    :FC => 'gfortran',
+    :FCFLAGS => '-O2 -Wall',
+    :CC => 'gcc',
+    :CFLAGS => '-O2 -Wall',
+    :CXX => 'g++',
+    :CXXFLAGS => '-O2 -Wall',
+    :NVCC => 'nvcc',
+    :NVCCFLAGS => '-O2',
+    :LDFLAGS => '',
+    :CLFLAGS => '',
+    :CLVENDOR => nil,
+    :CLPLATFORM => nil,
+    :CLDEVICE => nil,
+    :CLDEVICETYPE => nil,
+    :openmp => false
+  }
+  
+  @@openmp_default_flags = {
+    "gcc" => "-fopenmp",
+    "icc" => "-openmp",
+    "gfortran" => "-fopenmp",
+    "ifort" => "-openmp",
+    "g++" => "-fopenmp",
+    "icpc" => "-openmp"
+  }
+
+  module PrivateStateAccessor
+    private_boolean_state_accessor :verbose
+    private_boolean_state_accessor :debug_source
+    private_boolean_state_accessor :ffi
+  end
+
+  boolean_state_accessor :verbose
+  boolean_state_accessor :debug_source
+  boolean_state_accessor :ffi
+  @@ffi = false
+  @@verbose = false
+  @@debug_source = false
+  FORTRAN_LINE_LENGTH = 72
+
+  module_function
+
+  def read_boast_config
+    home_config_dir = ENV["XDG_CONFIG_HOME"]
+    home_config_dir = "#{Dir.home}/.config" if not home_config_dir
+    Dir.mkdir( home_config_dir ) if not File::exist?( home_config_dir )
+    return if not File::directory?(home_config_dir)
+    boast_config_dir = "#{home_config_dir}/BOAST"
+    Dir.mkdir( boast_config_dir ) if not File::exist?( boast_config_dir )
+    compiler_options_file = "#{boast_config_dir}/compiler_options"
+    if File::exist?( compiler_options_file ) then
+      File::open( compiler_options_file, "r" ) { |f|
+        @@compiler_default_options.update( YAML::load( f.read ) )
+      }
+    else
+      File::open( compiler_options_file, "w" ) { |f|
+        f.write YAML::dump( @@compiler_default_options )
+      }
+    end
+    openmp_flags_file = "#{boast_config_dir}/openmp_flags"
+    if File::exist?( openmp_flags_file ) then
+      File::open( openmp_flags_file, "r" ) { |f|
+        @@openmp_default_flags.update( YAML::load( f.read ) )
+      }
+    else
+      File::open( openmp_flags_file, "w" ) { |f|
+        f.write YAML::dump( @@openmp_default_flags )
+      }
+    end
+    @@compiler_default_options.each_key { |k|
+      @@compiler_default_options[k] = ENV[k.to_s] if ENV[k.to_s]
+    }
+    @@compiler_default_options[:LD] = ENV["LD"] if ENV["LD"]
+    @@verbose = ENV["VERBOSE"] if ENV["VERBOSE"]
+    @@ffi = ENV["FFI"] if ENV["FFI"]
+    @@debug_source = ENV["DEBUG_SOURCE"] if ENV["DEBUG_SOURCE"]
+  end
+
+  read_boast_config
+
+  def get_openmp_flags
+    return @@openmp_default_flags.clone
+  end
+
+  def get_compiler_options
+    return @@compiler_default_options.clone
+  end
+
+end