BOAST 2.0.2 → 2.1.0

data/lib/BOAST/Runtime/Compilers.rb

@@ -11,7 +11,7 @@ module BOAST
 
     def get_openmp_flags(compiler)
       openmp_flags = BOAST::get_openmp_flags[compiler]
-      if not openmp_flags then
+      unless openmp_flags then
         keys = BOAST::get_openmp_flags.keys
         keys.each { |k|
           openmp_flags = BOAST::get_openmp_flags[k] if compiler.match(k)
@@ -33,7 +33,7 @@ module BOAST
       begin
         spec = Gem::Specification::find_by_name('narray')
         narray_path = spec.require_path
-        if narray_path == "." then
+        unless File.exist?(narray_path+"/narray.h") then
           narray_path = spec.full_gem_path
         end
       rescue Gem::LoadError => e
@@ -42,7 +42,7 @@ module BOAST
         if spec then
           require 'narray'
           narray_path = Gem.loaded_specs['narray'].require_path
-          if narray_path == "." then
+          unless File.exist?(narray_path+"/narray.h") then
             narray_path = Gem.loaded_specs['narray'].full_gem_path
           end
         end
@@ -64,7 +64,7 @@ module BOAST
       objext = RbConfig::CONFIG["OBJEXT"]
       if (options[:openmp] or options[:OPENMP]) and @lang == C and not disable_openmp then
           openmp_cflags = get_openmp_flags(c_compiler)
-          raise "unkwown openmp flags for: #{c_compiler}" if not openmp_cflags
+          raise "unkwown openmp flags for: #{c_compiler}" unless openmp_cflags
           cflags += " #{openmp_cflags}"
       end
 
@@ -81,13 +81,13 @@ module BOAST
       end
 
       rule ".#{objext}io" => ".cio" do |t|
-        c_call_string = "#{c_mppa_compiler} -mcore=k1io -mos=rtems"
+        c_call_string = "#{c_mppa_compiler} -mcore=k1bio -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 = "#{c_mppa_compiler} -mcore=k1bdp -mos=nodeos"
         c_call_string += " -mboard=developer -x c -c -o #{t.name} #{t.source}"
         runner.call(t, c_call_string)
       end
@@ -99,7 +99,7 @@ module BOAST
       cxxflags += " -fPIC #{includes}"
       if (options[:openmp] or options[:OPENMP]) and @lang == C and not disable_openmp then
           openmp_cxxflags = get_openmp_flags(cxx_compiler)
-          raise "unkwown openmp flags for: #{cxx_compiler}" if not openmp_cxxflags
+          raise "unkwown openmp flags for: #{cxx_compiler}" unless openmp_cxxflags
           cxxflags += " #{openmp_cxxflags}"
       end
 
@@ -124,7 +124,7 @@ module BOAST
       fcflags += " -fno-second-underscore" if f_compiler == 'g95'
       if (options[:openmp] or options[:OPENMP]) and @lang == FORTRAN and not disable_openmp then
           openmp_fcflags = get_openmp_flags(f_compiler)
-          raise "unkwown openmp flags for: #{f_compiler}" if not openmp_fcflags
+          raise "unkwown openmp flags for: #{f_compiler}" unless openmp_fcflags
           fcflags += " #{openmp_fcflags}"
       end
 
@@ -161,12 +161,12 @@ module BOAST
       linker = "k1-gcc"
       
       rule ".bincomp" => ".#{objext}comp" do |t|
-        linker_string = "#{linker} -o #{t.name} #{t.source} -mcore=k1dp #{board} -mos=nodeos #{ldflags}"
+        linker_string = "#{linker} -o #{t.name} #{t.source} -mcore=k1bdp #{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}"
+        linker_string = "#{linker} -o #{t.name} #{t.source} -mcore=k1bio #{board} -mos=rtems #{ldflags}"
         runner.call(t, linker_string)
       end
 
@@ -188,12 +188,12 @@ module BOAST
       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
+      c_compiler = "cc" unless c_compiler
       linker = options[:LD]
-      linker = c_compiler if not linker
+      linker = c_compiler unless linker
       if (options[:openmp] or options[:OPENMP]) and not disable_openmp then
         openmp_ldflags = get_openmp_flags(linker)
-        raise "unknown openmp flags for: #{linker}" if not openmp_ldflags
+        raise "unknown openmp flags for: #{linker}" unless openmp_ldflags
         ldflags += " #{openmp_ldflags}"
       end
 
@@ -211,7 +211,7 @@ module BOAST
     def setup_compilers(probes, options = {})
       Rake::Task::clear
       verbose = options[:VERBOSE]
-      verbose = get_verbose if not verbose
+      verbose = get_verbose unless verbose
       Rake::verbose(verbose)
       Rake::FileUtilsExt.verbose_flag=verbose
 
@@ -223,7 +223,7 @@ module BOAST
           sh call_string
         else
           status, _, stderr = systemu call_string
-          if not status.success? then
+          unless status.success? then
             puts stderr
             fail "#{t.source}: compilation failed"
           end

data/lib/BOAST/Runtime/Config.rb

@@ -50,6 +50,7 @@ module BOAST
     private_boolean_state_accessor :executable
     private_boolean_state_accessor :keep_temp
     private_state_accessor :fortran_line_length
+    private_state_accessor :synchro
   end
 
   boolean_state_accessor :verbose
@@ -59,6 +60,7 @@ module BOAST
   boolean_state_accessor :executable
   boolean_state_accessor :keep_temp
   state_accessor         :fortran_line_length
+  state_accessor :synchro
   default_state_getter :verbose,             false
   default_state_getter :debug_source,        false
   default_state_getter :debug_kernel_source, false
@@ -66,6 +68,7 @@ module BOAST
   default_state_getter :executable,          false
   default_state_getter :keep_temp,           false
   default_state_getter :fortran_line_length, 72
+  default_state_getter :synchro,             "MUTEX"
 
   module_function
 

data/lib/BOAST/Runtime/EnergyProbe.rb

@@ -6,32 +6,28 @@ module BOAST
       get_output.puts "#include <stdio.h>"
       get_output.puts "#include <stdint.h>"
     end
-    def decl
-      get_output.puts "char **_boast_energy_files = 0;"
-      get_output.puts "char **_boast_energy_names = 0;"
-      get_output.puts "uint64_t *_boast_energy_0  = 0;"
-      get_output.puts "uint64_t *_boast_energy_1  = 0;"
-      get_output.puts "int _boast_energy_nsensors = 0;"
-    end
-    def configure
+    def preamble
       get_output.print <<EOF
-{
+struct _boast_powercap_param_struct {
+  char **files;
+  char **names;
+  uint64_t *energy_0;
+  uint64_t *energy_1;
+  int nsensors;
+};
+
+static int _boast_powercap_init(uint64_t **energy_0, uint64_t **energy_1, char ***files, char ***names);
+static int _boast_powercap_init(uint64_t **energy_0, uint64_t **energy_1, char ***files, char ***names) {
+  int nsensors = 0;
   char buf[128];
   char path[128];
   char *s;
   FILE *f;
   int nproc;
   int i;
-  if( _boast_energy_nsensors ){
-    free(_boast_energy_files);
-    for(i=0; i < _boast_energy_nsensors; ++i)
-      free(_boast_energy_names[i]);
-    free(_boast_energy_names);
-    _boast_energy_nsensors = 0;
-  }
-  _boast_energy_files = malloc(1);
-  _boast_energy_names = malloc(1);
 
+  *files = malloc(1);
+  *names = malloc(1);
   for(nproc = 0; ; ++nproc){
     sprintf(path,"/sys/devices/virtual/powercap/intel-rapl/intel-rapl:%d",nproc);
     sprintf(buf,"%s/energy_uj",path);
@@ -39,90 +35,105 @@ module BOAST
     if(!f)
       break;
     i = 0;
-    do{
-      int _boast_fread_ret;
+    do {
+      int fread_ret;
       fclose(f);
-      ++_boast_energy_nsensors;
-      _boast_energy_files = realloc(_boast_energy_files, _boast_energy_nsensors * sizeof(*_boast_energy_files));
-      _boast_energy_names = realloc(_boast_energy_names, _boast_energy_nsensors * sizeof(*_boast_energy_names));
-      _boast_energy_files[_boast_energy_nsensors-1] = malloc(128);
-      _boast_energy_names[_boast_energy_nsensors-1] = malloc( 16);
-      s = _boast_energy_names[_boast_energy_nsensors-1];
-      sprintf(_boast_energy_files[_boast_energy_nsensors-1],"%s",buf);
+      ++nsensors;
+      *files = realloc(*files, nsensors * sizeof(**files));
+      *names = realloc(*names, nsensors * sizeof(**names));
+      (*files)[nsensors-1] = malloc(128);
+      (*names)[nsensors-1] = malloc( 16);
+      s = (*names)[nsensors-1];
+      sprintf((*files)[nsensors-1],"%s",buf);
       sprintf(buf, "%s/name", path);
       f = fopen(buf, "r");
-      _boast_fread_ret = fread(buf, 1, sizeof(buf), f);
+      fread_ret = fread(buf, 1, sizeof(buf), f);
       fclose(f);
-      if(_boast_fread_ret == 0)
+      if(fread_ret == 0)
         rb_raise(rb_eArgError, "Energy probe read error!");
       /* last character read is a line break */
-      buf[_boast_fread_ret-1] = 0;
+      buf[fread_ret-1] = 0;
       sprintf(s, "%d.%s", nproc, buf);
 
       sprintf(path,"/sys/devices/virtual/powercap/intel-rapl/intel-rapl:%d/intel-rapl:%d:%d",nproc,nproc,i++);
       sprintf(buf,"%s/energy_uj",path);
       f = fopen(buf, "rt");
-    }while(f);
+    } while(f);
   }
-  if( ! _boast_energy_nsensors ){
-    free( _boast_energy_files );
-    free( _boast_energy_names );
-  }else{
-    _boast_energy_0 = malloc(_boast_energy_nsensors * sizeof(*_boast_energy_0));
-    _boast_energy_1 = malloc(_boast_energy_nsensors * sizeof(*_boast_energy_1));
+  if( ! nsensors ) {
+    free( *files );
+    free( *names );
+  } else {
+    *energy_0 = malloc(nsensors * sizeof(**energy_0));
+    *energy_1 = malloc(nsensors * sizeof(**energy_1));
   }
+  return nsensors;
 }
-EOF
-    end
-    def start
-      get_output.print <<EOF
-{
+
+static void _boast_powercap_read(int nsensors, char **files, uint64_t *energy);
+static void _boast_powercap_read(int nsensors, char **files, uint64_t *energy) {
   char buf[32];
   FILE *f;
   int i;
-  for(i = 0; i < _boast_energy_nsensors; ++i){
-    int _boast_fread_ret;
-    f = fopen(_boast_energy_files[i], "r");
-    _boast_fread_ret = fread(buf, 1, sizeof(buf), f);
+  for(i = 0; i < nsensors; ++i){
+    int fread_ret;
+    f = fopen(files[i], "r");
+    fread_ret = fread(buf, 1, sizeof(buf), f);
     fclose(f);
-    if(_boast_fread_ret == 0)
+    if(fread_ret == 0) {
       rb_raise(rb_eArgError, "Energy probe read error!");
-    _boast_energy_0[i] = atoll(buf);
+    }
+    energy[i] = atoll(buf);
   }
 }
+
+static void _boast_powercap_store_and_clean( int nsensors, uint64_t *energy_0, uint64_t *energy_1, char **files, char **names, VALUE _boast_stats);
+static void _boast_powercap_store_and_clean( int nsensors, uint64_t *energy_0, uint64_t *energy_1, char **files, char **names, VALUE _boast_stats) {
+  VALUE results;
+  int i;
+  if( nsensors ) {
+    results = rb_hash_new();
+    for(i=0; i < nsensors; ++i){
+      rb_hash_aset(results, ID2SYM(rb_intern(names[i])), rb_float_new((energy_1[i] - energy_0[i]) * 1e-6));
+    }
+    rb_hash_aset(_boast_stats, ID2SYM(rb_intern("energy")), results);
+
+    free(energy_0);
+    free(energy_1);
+    for(i=0; i < nsensors; ++i){
+      free(files[i]);
+      free(names[i]);
+    }
+    free(files);
+    free(names);
+  }
+}
+
+EOF
+    end
+    def decl
+      get_output.puts "  struct _boast_powercap_param_struct _boast_powercap_params = {0,0,0,0,0};"
+    end
+    def configure
+      get_output.print <<EOF
+  _boast_powercap_params.nsensors = _boast_powercap_init(&_boast_powercap_params.energy_0, &_boast_powercap_params.energy_1, &_boast_powercap_params.files, &_boast_powercap_params.names);
+EOF
+    end
+    def start
+      get_output.print <<EOF
+  _boast_powercap_read(_boast_powercap_params.nsensors, _boast_powercap_params.files, _boast_powercap_params.energy_0);
 EOF
     end
     def stop
       get_output.print <<EOF
-{
-  char buf[32];
-  FILE *f;
-  int i;
-  for(i = 0; i < _boast_energy_nsensors; ++i){
-    int _boast_fread_ret;
-    f = fopen(_boast_energy_files[i], "r");
-    _boast_fread_ret = fread(buf, 1, sizeof(buf), f);
-    fclose(f);
-    if(_boast_fread_ret == 0)
-      rb_raise(rb_eArgError, "Energy probe read error!");
-    _boast_energy_1[i] = atoll(buf);
-  }
-}
+  _boast_powercap_read(_boast_powercap_params.nsensors, _boast_powercap_params.files, _boast_powercap_params.energy_1);
 EOF
     end
     def compute
     end
     def store
       get_output.print <<EOF
-{
-  VALUE results;
-  int i;
-  results = rb_hash_new();
-  for(i=0; i < _boast_energy_nsensors; ++i){
-    rb_hash_aset(results, ID2SYM(rb_intern(_boast_energy_names[i])), rb_float_new((_boast_energy_1[i] - _boast_energy_0[i]) * 1e-6));
-  }
-  rb_hash_aset(_boast_stats, ID2SYM(rb_intern("energy")), results);
-}
+  _boast_powercap_store_and_clean( _boast_powercap_params.nsensors, _boast_powercap_params.energy_0, _boast_powercap_params.energy_1, _boast_powercap_params.files, _boast_powercap_params.names, _boast_stats);
 EOF
     end
     def is_available?
@@ -136,6 +147,8 @@ EOF
     def header
       get_output.puts "#include <redfst.h>"
     end
+    def preamble
+    end
     def decl
       get_output.puts "redfst_dev_t *_boast_energy=0;"
     end
@@ -202,6 +215,8 @@ EOF
     def header
       get_output.puts "#include <eml.h>"
     end
+    def preamble
+    end
     def decl
       get_output.puts "emlData_t **_boast_energy=0;";
       get_output.puts "size_t _boast_energy_count=0;";

data/lib/BOAST/Runtime/FFIRuntime.rb

@@ -111,7 +111,7 @@ EOF
               ev_set.destroy
             end
           end
-          results = { :start => start, :stop => stop, :duration => stop - start, :return => ret }
+          results = { :start => start, :end => 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 = {}

data/lib/BOAST/Runtime/FORTRANRuntime.rb

@@ -44,16 +44,26 @@ module BOAST
       end
     end
 
+    def create_procedure_indirect_call_parameters
+      return @procedure.parameters.collect { |param|
+        par = "#{param_struct.struct_reference(param_struct.type.members[param.name.to_s])}".gsub("_boast_params.","_boast_params->")
+        if param.dimension then
+          "#{par}"
+        else
+          "&#{par}"
+        end
+      }
+    end
+
     def create_procedure_call_parameters
-      params = []
-      @procedure.parameters.each { |param|
+      return @procedure.parameters.collect { |param|
+        par = param_struct.struct_reference(param_struct.type.members[param.name.to_s])
         if param.dimension then
-          params.push( param.name )
+          "#{par}"
         else
-          params.push( "&"+param.name )
+          "&#{par}"
         end
       }
-      return params
     end
 
   end

data/lib/BOAST/Runtime/MPPARuntime.rb

@@ -11,6 +11,9 @@ module BOAST
       get_output.puts "#include <mppa_mon.h>"
     end
 
+    def preamble
+    end
+
     def decl
       get_output.print <<EOF
   float _mppa_avg_pwr;
@@ -47,6 +50,11 @@ EOF
   _mppa_duration = _mppa_report->total_time;
   mppa_mon_measure_free_report(_mppa_report);
   mppa_mon_close(_mppa_ctx);
+EOF
+    end
+
+    def store
+      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));
@@ -111,7 +119,7 @@ EOF
     end
 
     def set_io
-      set_output(@code_io)
+      set_output(@code)
     end
 
     def set_comp
@@ -151,8 +159,8 @@ EOF
       f.close
     end
 
-    def create_targets( linker, ldshared, ldflags, kernel_files )
-      create_targets_old( linker, ldshared, ldflags, kernel_files )
+    def create_targets( linker, ldshared, ldshared_flags, ldflags, kernel_files )
+      create_targets_old( linker, ldshared, ldshared_flags, 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
@@ -392,7 +400,7 @@ EOF
 EOF
     end
 
-    def copy_array_param_from_ruby( param, ruby_param )
+    def copy_array_param_from_ruby(par, param, ruby_param )
       rb_ptr = Variable::new("_boast_rb_ptr", CustomType, :type_name => "VALUE")
       (rb_ptr === ruby_param).pr
       get_output.print <<EOF
@@ -402,23 +410,23 @@ EOF
     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);
+    #{par} = (void *) _boast_n_ary->ptr;
+    mppa_write(_mppa_fd_var, #{par}, _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 )
+    def copy_scalar_param_from_ruby(par, 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
+        (par === FuncCall::new("NUM2INT", ruby_param)).pr if param.type.size == 4
+        (par === FuncCall::new("NUM2LONG", ruby_param)).pr if param.type.size == 8
       when Real
-        (param === FuncCall::new("NUM2DBL", ruby_param)).pr
+        (par === FuncCall::new("NUM2DBL", ruby_param)).pr
       end
-      get_output.puts "  mppa_write(_mppa_fd_var, &#{param}, sizeof(#{param}));"
+      get_output.puts "  mppa_write(_mppa_fd_var, &#{par}, sizeof(#{par}));"
     end
 
     def get_params_value
@@ -460,7 +468,7 @@ EOF
     def create_procedure_call
     end
 
-    def copy_array_param_to_ruby(param, ruby_param)
+    def copy_array_param_to_ruby(par, param, ruby_param)
       rb_ptr = Variable::new("_boast_rb_ptr", CustomType, :type_name => "VALUE")
       (rb_ptr === ruby_param).pr
       get_output.print <<EOF
@@ -472,7 +480,7 @@ EOF
     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);
+    mppa_read(_mppa_fd_var, #{par}, _boast_array_size);
 EOF
       end
         get_output.print <<EOF
@@ -482,17 +490,20 @@ EOF
 EOF
     end
 
-    def copy_scalar_param_to_ruby(param, ruby_param)
+    def copy_scalar_param_to_ruby(par, param, ruby_param)
       if param.scalar_output? then
         get_output.print <<EOF
-  mppa_read(_mppa_fd_var, &#{param}, sizeof(#{param}));
+  mppa_read(_mppa_fd_var, &#{par}, sizeof(#{par}));
 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?
+          if param.type.signed? then
+            get_output.puts "  rb_hash_aset(_boast_refs, ID2SYM(rb_intern(\"#{param}\")),rb_int_new((long long)#{par}));"
+          else
+            get_output.puts "  rb_hash_aset(_boast_refs, ID2SYM(rb_intern(\"#{param}\")),rb_int_new((unsigned long long)#{par}));"
+          end
         when Real
-          get_output.puts "  rb_hash_aset(_boast_refs, ID2SYM(rb_intern(\"#{param}\")),rb_float_new((double)#{param}));"
+          get_output.puts "  rb_hash_aset(_boast_refs, ID2SYM(rb_intern(\"#{param}\")),rb_float_new((double)#{par}));"
         end
       end
     end
@@ -502,7 +513,7 @@ 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.puts "  mppa_read(_mppa_fd_var, &_boast_params._boast_ret, sizeof(_boast_params._boast_ret));" if @procedure.properties[:return]
       get_output.puts "  mppa_read(_mppa_fd_var, &_boast_duration, sizeof(_boast_duration));"
       get_output.print <<EOF
   mppa_close(_mppa_fd_var);