BOAST 1.0.3 → 1.0.4

data/lib/BOAST/Runtime/FFIRuntime.rb

@@ -0,0 +1,104 @@
+module BOAST
+
+  module FFIRuntime
+
+    def target
+      return library_path
+    end
+
+    def target_depends
+      return [ library_object ]
+    end
+
+    def target_sources
+      return [ library_source ]
+    end
+
+    def load_module
+      create_ffi_module
+    end
+
+    def create_sources
+      create_library_source
+    end
+
+    def create_ffi_module
+      s =<<EOF
+      require 'ffi'
+      require 'narray_ffi'
+      module #{module_name}
+        extend FFI::Library
+        ffi_lib "#{library_path}"
+        attach_function :#{method_name}, [ #{@procedure.parameters.collect{ |p| ":"+p.decl_ffi.to_s }.join(", ")} ], :#{@procedure.properties[:return] ? @procedure.properties[:return].type.decl_ffi : "void" }
+        def run(*args)
+          if args.length < @procedure.parameters.length or args.length > @procedure.parameters.length + 1 then
+            raise "Wrong number of arguments for \#{@procedure.name} (\#{args.length} for \#{@procedure.parameters.length})"
+          else
+            ev_set = nil
+            if args.length == @procedure.parameters.length + 1 then
+              options = args.last
+              if options[:PAPI] then
+                require 'PAPI'
+                ev_set = PAPI::EventSet::new
+                ev_set.add_named(options[:PAPI])
+              end
+            end
+            t_args = []
+            r_args = {}
+            if @lang == FORTRAN then
+              @procedure.parameters.each_with_index { |p, i|
+                if p.decl_ffi(true) != :pointer then
+                  arg_p = FFI::MemoryPointer::new(p.decl_ffi(true))
+                  arg_p.send("write_\#{p.decl_ffi(true)}",args[i])
+                  t_args.push(arg_p)
+                  r_args[p] = arg_p if p.scalar_output?
+                else
+                  t_args.push( args[i] )
+                end
+              }
+            else
+              @procedure.parameters.each_with_index { |p, i|
+                if p.scalar_output? then
+                  arg_p = FFI::MemoryPointer::new(p.decl_ffi(true))
+                  arg_p.send("write_\#{p.decl_ffi(true)}",args[i])
+                  t_args.push(arg_p)
+                  r_args[p] = arg_p
+                else
+                  t_args.push( args[i] )
+                end
+              }
+            end
+            results = {}
+            counters = nil
+            ev_set.start if ev_set
+            begin
+              start = Time::new
+              ret = #{method_name}(*t_args)
+              stop = Time::new
+            ensure
+              if ev_set then
+                counters = ev_set.stop
+                ev_set.cleanup
+                ev_set.destroy
+              end
+            end
+            results = { :start => start, :stop => stop, :duration => stop - start, :return => ret }
+            results[:PAPI] = Hash[[options[:PAPI]].flatten.zip(counters)] if ev_set
+            if r_args.length > 0 then
+              ref_return = {}
+              r_args.each { |p, p_arg|
+                ref_return[p.name.to_sym] = p_arg.send("read_\#{p.decl_ffi(true)}")
+              }
+              results[:reference_return] = ref_return
+            end
+            return results
+          end
+        end
+      end
+EOF
+      BOAST::class_eval s
+    end
+
+  end
+
+end

data/lib/BOAST/Runtime/FORTRANRuntime.rb

@@ -0,0 +1,45 @@
+module BOAST
+
+  module FORTRANRuntime
+    include CompiledRuntime
+
+    def method_name
+      return @procedure.name + "_"
+    end
+
+    def fill_library_source
+      @code.rewind
+      @code.each_line { |line|
+        # check for omp pragmas
+        if line.match(/^\s*!\$/) then
+          if line.match(/^\s*!\$(omp|OMP)/) then
+            chunks = line.scan(/.{1,#{FORTRAN_LINE_LENGTH-7}}/)
+            get_output.puts chunks.join("&\n!$omp&")
+          else
+            chunks = line.scan(/.{1,#{FORTRAN_LINE_LENGTH-4}}/)
+            get_output.puts chunks.join("&\n!$&")
+          end
+        elsif line.match(/^\w*!/) then
+          get_output.write line
+        else
+          chunks = line.scan(/.{1,#{FORTRAN_LINE_LENGTH-2}}/)
+          get_output.puts chunks.join("&\n&")
+        end
+      }
+    end
+
+    def create_procedure_call_parameters
+      params = []
+      @procedure.parameters.each { |param|
+        if param.dimension then
+          params.push( param.name )
+        else
+          params.push( "&"+param.name )
+        end
+      }
+      return params
+    end
+
+  end
+
+end

data/lib/BOAST/Runtime/MPPARuntime.rb

@@ -0,0 +1,464 @@
+module BOAST
+
+  module MPPARuntime
+    include CRuntime
+
+    alias create_targets_old create_targets
+    alias cleanup_old cleanup
+    alias fill_module_header_old fill_module_header
+    alias get_params_value_old get_params_value
+    alias fill_decl_module_params_old fill_decl_module_params
+    alias get_results_old get_results
+    alias store_results_old store_results
+
+    def cleanup(kernel_files)
+      cleanup_old(kernel_files)
+      ([io_bin, comp_bin, io_object, comp_object]).each { |fn|
+        File::unlink(fn)
+      }
+    end
+
+    def target_depends
+      return [ module_file_object ]
+    end
+
+    def target_sources
+      return [ module_file_source, io_source, comp_source ]
+    end
+
+    def multibinary_path
+      return "#{base_path}.mpk"
+    end
+
+    def io_bin
+      return "#{base_path}.binio"
+    end
+
+    def comp_bin
+      return "#{base_path}.bincomp"
+    end
+
+    def io_object
+      return "#{base_path}.#{RbConfig::CONFIG["OBJEXT"]}io"
+    end
+
+    def comp_object
+      return "#{base_path}.#{RbConfig::CONFIG["OBJEXT"]}comp"
+    end
+
+    def io_source
+      return "#{base_path}.cio"
+    end
+
+    def comp_source
+      return "#{base_path}.ccomp"
+    end
+
+    def set_io
+      set_output(@code_io)
+    end
+
+    def set_comp
+      @code_comp = StringIO::new unless @code_comp
+      set_output(@code_comp)
+    end
+
+    attr_accessor :code_comp
+    attr_accessor :procedure_comp
+    attr_accessor :binary_comp
+    attr_accessor :multibinary
+
+    def save_binary
+      f = File::open(io_object,"rb")
+      @binary = StringIO::new
+      @binary.write( f.read )
+      f.close
+      f = File::open(comp_object,"rb")
+      @binary_comp = StringIO::new
+      @binary_comp.write( f.read )
+      f.close
+      f = File::open(multibinary_path,"rb")
+      @multibinary = StringIO::new
+      @multibinary.write( f.read )
+      f.close
+    end
+
+    def create_targets( linker, ldshared, ldflags, kernel_files )
+      create_targets_old( linker, ldshared, ldflags, kernel_files )
+      file multibinary_path => [io_bin, comp_bin] do
+        sh "k1-create-multibinary --clusters #{comp_bin} --clusters-names \"comp-part\" --boot #{io_bin} --bootname \"io-part\" -T #{multibinary_path}"
+      end
+      Rake::Task[multibinary_path].invoke
+    end
+
+    def fill_multibinary_header
+      fill_library_header
+      get_output.puts "#include <mppaipc.h>"
+      get_output.puts "#include <mppa/osconfig.h>"
+    end
+
+    def copy_array_param_from_host( param )
+      get_output.write <<EOF
+  mppa_read(_mppa_from_host_size, &_mppa_#{param}_size, sizeof(_mppa_#{param}_size));
+  #{param} = malloc(_mppa_#{param}_size);
+  mppa_read(_mppa_from_host_var, #{param}, _mppa_#{param}_size);
+EOF
+    end
+
+    def copy_scalar_param_from_host( param )
+      get_output.write  <<EOF
+  mppa_read(_mppa_from_host_var, &#{param}, sizeof(#{param}));
+EOF
+    end
+
+    def get_cluster_list_from_host
+      get_output.write <<EOF
+  mppa_read(_mppa_from_host_size, &_mppa_clust_list_size, sizeof(_mppa_clust_list_size));
+  _clust_list = malloc(_mppa_clust_list_size);
+  _nb_clust = _mppa_clust_list_size / sizeof(*_clust_list);
+  mppa_read(_mppa_from_host_var, _clust_list, _mppa_clust_list_size);
+EOF
+    end
+
+    def copy_array_param_to_host(param)
+      get_output.write <<EOF
+  mppa_write(_mppa_to_host_var, #{param}, _mppa_#{param}_size);
+EOF
+    end
+
+    def copy_scalar_param_to_host(param)
+      get_output.write <<EOF
+  mppa_write(_mppa_to_host_var, &#{param}, sizeof(#{param}));
+EOF
+    end
+
+    def multibinary_main_io_source_decl
+      #Parameters declaration
+      @procedure.parameters.each { |param|
+        get_output.write "  #{param.type.decl} "
+        get_output.write "*" if param.dimension or param.scalar_output?
+        get_output.puts "#{param.name};"
+        if param.dimension then
+          get_output.puts "  size_t _mppa_#{param}_size;"
+        end
+      }
+
+      #Return value declaration
+      get_output.puts "  #{@procedure.properties[:return].type.decl} _mppa_ret;" if @procedure.properties[:return]
+
+      #Cluster list declaration
+      get_output.write <<EOF
+  uint32_t *_clust_list;
+  int _nb_clust;
+  int _mppa_clust_list_size;
+EOF
+
+      #Communication variables
+      get_output.write <<EOF
+  int _mppa_from_host_size, _mppa_from_host_var;
+  int _mppa_to_host_size,   _mppa_to_host_var;
+  int _mppa_pid[16], _mppa_i;
+EOF
+    end
+
+    def multibinary_main_io_source_get_params
+      #Receiving parameters from Host
+      get_output.write <<EOF
+  _mppa_from_host_size = mppa_open("/mppa/buffer/board0#mppa0#pcie0#2/host#2", O_RDONLY);
+  _mppa_from_host_var = mppa_open("/mppa/buffer/board0#mppa0#pcie0#3/host#3", O_RDONLY);
+EOF
+      @procedure.parameters.each { |param|
+        if param.dimension then
+          copy_array_param_from_host(param)
+        else
+          copy_scalar_param_from_host(param)
+        end
+      }
+
+      #Receiving cluster list
+      get_cluster_list_from_host
+
+      get_output.write <<EOF
+  mppa_close(_mppa_from_host_size);
+  mppa_close(_mppa_from_host_var);
+EOF
+    end
+
+    def multibinary_main_io_source_send_results
+      #Sending results to Host
+      get_output.write <<EOF
+  _mppa_to_host_var = mppa_open("/mppa/buffer/host#4/board0#mppa0#pcie0#4", O_WRONLY);
+EOF
+      @procedure.parameters.each { |param| 
+        if param.direction == :out or param.direction == :inout then
+          if param.dimension then
+            copy_array_param_to_host(param)
+          else
+            copy_scalar_param_to_host(param)
+          end
+        end
+      }
+      copy_scalar_param_to_host("_mppa_ret") if @procedure.properties[:return]
+      get_output.write <<EOF
+  mppa_close(_mppa_to_host_var);
+EOF
+    end
+
+    def fill_multibinary_main_io_source
+      multibinary_main_io_source_decl
+
+      multibinary_main_io_source_get_params
+
+      #Spawning cluster
+      get_output.write <<EOF
+  for(_mppa_i=0; _mppa_i<_nb_clust; _mppa_i++){
+    _mppa_pid[_mppa_i] = mppa_spawn(_clust_list[_mppa_i], NULL, "comp-part", NULL, NULL);
+  }
+EOF
+      #Calling IO procedure
+      get_output.write "  _mppa_ret =" if @procedure.properties[:return]
+      get_output.write "  #{@procedure.name}("
+      get_output.write @procedure.parameters.map(&:name).join(", ")
+      get_output.puts ");"
+
+      #Waiting for clusters
+      get_output.write <<EOF
+  for(_mppa_i=0; _mppa_i<_nb_clust; _mppa_i++){
+    mppa_waitpid(_mppa_pid[_mppa_i], NULL, 0);
+  }
+EOF
+
+      multibinary_main_io_source_send_results
+    end
+
+    def fill_multibinary_main_comp_source
+      if @procedure_comp then
+        get_output.puts "    #{@procedure_comp.name}();"
+      end
+    end
+
+    def fill_multibinary_source(mode)
+      fill_multibinary_header
+      code = nil
+      if mode == :io then
+        code = @code
+      else
+        code = @code_comp
+      end
+      if code then
+        code.rewind
+        get_output.write code.read
+      end
+      get_output.puts "int main(int argc, const char* argv[]) {"
+      if mode == :io then
+        fill_multibinary_main_io_source
+      else
+        fill_multibinary_main_comp_source
+      end
+      get_output.write <<EOF
+  mppa_exit(0);
+  return 0;
+}
+EOF
+    end
+
+    def create_multibinary_source(mode)
+      f = File::open(self.send("#{mode}_source"),"w+")
+      previous_lang = get_lang
+      previous_output = get_output
+      set_output(f)
+      set_lang(@lang)
+
+      fill_multibinary_source(mode)
+
+      if debug_source? then
+        f.rewind
+        puts f.read
+      end
+      set_output(previous_output)
+      set_lang(previous_lang)
+      f.close
+    end
+
+    def create_multibinary_sources
+      create_multibinary_source(:io)
+      create_multibinary_source(:comp)
+    end
+
+    def create_sources
+      create_multibinary_sources
+      create_module_file_source
+    end
+
+    def fill_module_header
+      fill_module_header_old
+      get_output.puts "#include <mppaipc.h>"
+      get_output.puts "#include <mppa_mon.h>"
+    end
+
+    def fill_decl_module_params
+      fill_decl_module_params_old
+      get_output.print <<EOF
+  int _mppa_i;
+  int _mppa_load_id;
+  int _mppa_pid;
+  int _mppa_fd_size;
+  int _mppa_fd_var;
+  float _mppa_avg_pwr;
+  float _mppa_energy;
+  float _mppa_duration;
+  int _mppa_clust_list_size;
+  int _mppa_clust_nb;
+  uint32_t * _mppa_clust_list;
+  mppa_mon_ctx_t * _mppa_ctx;
+  mppa_mon_sensor_t _mppa_pwr_sensor[] = {MPPA_MON_PWR_MPPA0};
+  mppa_mon_measure_report_t * _mppa_report;
+  mppa_mon_open(0, &_mppa_ctx);
+  mppa_mon_measure_set_sensors(_mppa_ctx, _mppa_pwr_sensor, 1);
+  _mppa_load_id = mppa_load(0, 0, 0, \"#{multibinary_path}\");
+  mppa_mon_measure_start(_mppa_ctx);
+  _mppa_pid = mppa_spawn(_mppa_load_id, NULL, \"io-part\", NULL, NULL);
+EOF
+    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 ( IsNArray(_boast_rb_ptr) ) {
+    struct NARRAY *_boast_n_ary;
+    size_t _boast_array_size;
+    Data_Get_Struct(_boast_rb_ptr, struct NARRAY, _boast_n_ary);
+    _boast_array_size = _boast_n_ary->total * na_sizeof[_boast_n_ary->type];
+    mppa_write(_mppa_fd_size, &_boast_array_size, sizeof(_boast_array_size));
+    #{param} = (void *) _boast_n_ary->ptr;
+    mppa_write(_mppa_fd_var, #{param}, _boast_array_size);
+  } else {
+    rb_raise(rb_eArgError, "Wrong type of argument for %s, expecting array!", "#{param}");
+  }
+EOF
+    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
+      get_output.puts "  mppa_write(_mppa_fd_var, &#{param}, sizeof(#{param}));"
+    end
+
+    def get_params_value
+      get_output.print <<EOF
+  _mppa_fd_size = mppa_open(\"/mppa/buffer/board0#mppa0#pcie0#2/host#2\", O_WRONLY);
+  _mppa_fd_var = mppa_open(\"/mppa/buffer/board0#mppa0#pcie0#3/host#3\", O_WRONLY);
+EOF
+      get_params_value_old
+      get_output.print <<EOF
+  if(_boast_rb_opts != Qnil) {
+    _boast_rb_ptr = rb_hash_aref(_boast_rb_opts, ID2SYM(rb_intern("clusters")));
+    if (_boast_rb_ptr != Qnil ) {
+      int _boast_i;
+      _mppa_clust_nb = RARRAY_LEN(_boast_rb_ptr);
+      _mppa_clust_list = malloc(sizeof(uint32_t)*_mppa_clust_nb);
+      for(_boast_i=0; _boast_i < _mppa_clust_nb; _boast_i++){
+        _mppa_clust_list[_boast_i] = NUM2INT(rb_ary_entry(_boast_rb_ptr, _boast_i));
+      }
+    } else {
+      _mppa_clust_list = malloc(sizeof(uint32_t));
+      _mppa_clust_list[0] = 0;
+      _mppa_clust_nb = 1;
+    }
+  } else {
+    _mppa_clust_list = malloc(sizeof(uint32_t));
+    _mppa_clust_list[0] = 0;
+    _mppa_clust_nb = 1;
+  }
+  
+  _mppa_clust_list_size = sizeof(uint32_t)*_mppa_clust_nb;
+  mppa_write(_mppa_fd_size, &_mppa_clust_list_size, sizeof(_mppa_clust_list_size));
+  mppa_write(_mppa_fd_var, _mppa_clust_list, _mppa_clust_list_size);
+  free(_mppa_clust_list);
+  mppa_close(_mppa_fd_var);
+  mppa_close(_mppa_fd_size);
+EOF
+    end
+
+    def create_procedure_call
+    end
+
+    def copy_array_param_to_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 ( IsNArray(_boast_rb_ptr) ) {
+EOF
+      if param.direction == :out or param.direction == :inout then
+        get_output.print <<EOF
+    struct NARRAY *_boast_n_ary;
+    size_t _boast_array_size;
+    Data_Get_Struct(_boast_rb_ptr, struct NARRAY, _boast_n_ary);
+    _boast_array_size = _boast_n_ary->total * na_sizeof[_boast_n_ary->type];
+    mppa_read(_mppa_fd_var, #{param}, _boast_array_size);
+EOF
+      end
+        get_output.print <<EOF
+  } else {
+    rb_raise(rb_eArgError, "Wrong type of argument for %s, expecting array!", "#{param}");
+  }
+EOF
+    end
+
+    def copy_scalar_param_to_ruby(param, ruby_param)
+      if param.scalar_output? then
+        get_output.print <<EOF
+  mppa_read(_mppa_fd_var, &#{param}, sizeof(#{param}));
+EOF
+        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 get_results
+      get_output.print <<EOF
+  _mppa_fd_var = mppa_open(\"/mppa/buffer/host#4/board0#mppa0#pcie0#4\", O_RDONLY);
+EOF
+      get_results_old
+      get_output.puts "mppa_read(_mppa_fd_var, &#{_boast_ret}, sizeof(#{_boast_ret}));" if @procedure.properties[:return]
+      get_output.print <<EOF
+  mppa_close(_mppa_fd_var);
+  mppa_waitpid(_mppa_pid, NULL, 0);
+  mppa_mon_measure_stop(_mppa_ctx, &_mppa_report);
+  mppa_unload(_mppa_load_id);
+  _mppa_avg_pwr = 0;
+  _mppa_energy = 0;
+  for(_mppa_i=0; _mppa_i < _mppa_report->count; _mppa_i++){
+    _mppa_avg_pwr += _mppa_report->measures[_mppa_i].avg_power;
+    _mppa_energy += _mppa_report->measures[_mppa_i].total_energy;
+  } 
+  _mppa_avg_pwr = _mppa_avg_pwr/(float) _mppa_report->count;
+  _mppa_duration = _mppa_report->total_time;
+  mppa_mon_measure_free_report(_mppa_report);
+  mppa_mon_close(_mppa_ctx);
+EOF
+    end
+
+    def store_results
+      store_results_old
+      get_output.print <<EOF
+  rb_hash_aset(_boast_stats,ID2SYM(rb_intern("mppa_avg_pwr")),rb_float_new(_mppa_avg_pwr));
+  rb_hash_aset(_boast_stats,ID2SYM(rb_intern("mppa_energy")),rb_float_new(_mppa_energy));
+  rb_hash_aset(_boast_stats,ID2SYM(rb_intern("mppa_duration")), rb_float_new(_mppa_duration));
+EOF
+    end
+
+  end
+
+end