BOAST 2.0.2 → 2.1.0

data/lib/BOAST/Runtime/AffinityProbe.rb

@@ -1,26 +1,75 @@
 module BOAST
 
   # @private
-  module AffinityProbe
+  module HwlocProbe
     extend PrivateStateAccessor
 
+    class << self
+      attr_accessor :topology
+    end
+    @topology = nil
+
+    begin
+      require 'hwloc'
+      @topology = Hwloc::Topology::new
+      @topology.load
+    rescue LoadError => e
+    end
+
     module_function
 
     def cflags
-      return "-D_GNU_SOURCE"
     end
 
     def header
-      get_output.puts "#include <sched.h>"
     end
 
+    def preamble
+    end
+
+
     def decl
-      get_output.puts "  cpu_set_t _boast_affinity_mask_old;"
-      get_output.puts "  int _boast_affinity_set = 0;"
     end
 
     def configure
-      get_output.print <<EOF
+    end
+
+    def start
+    end
+
+    def stop
+    end
+
+    def compute
+    end
+
+    def store
+    end
+
+    def is_available?
+      return  !@topology.nil?
+    end
+
+  end
+
+  # @private
+  module PthreadAffinityProbe
+    extend PrivateStateAccessor
+
+    module_function
+
+    def cflags
+      return "-D_GNU_SOURCE"
+    end
+
+    def header
+      get_output.puts "#include <sched.h>"
+    end
+
+    def preamble
+      get_output.puts <<EOF
+static int _boast_affinity_setup( VALUE _boast_rb_opts, cpu_set_t * _boast_affinity_mask_old );
+static int _boast_affinity_setup( VALUE _boast_rb_opts, cpu_set_t * _boast_affinity_mask_old ) {
   if( _boast_rb_opts != Qnil ) {
     VALUE _boast_affinity_rb_ptr = Qnil;
 
@@ -31,18 +80,43 @@ module BOAST
       int _boast_affinity_counter;
       int _boast_affinity_cpu_number;
 
-      if( TYPE(_boast_affinity_rb_ptr) != T_ARRAY )
+      if( TYPE(_boast_affinity_rb_ptr) != T_ARRAY ) {
         rb_raise(rb_eArgError, "Option :cpu_affinity should be an array!");
+      }
       CPU_ZERO(&_boast_affinity_mask);
       _boast_affinity_cpu_number = RARRAY_LEN(_boast_affinity_rb_ptr);
-      for( _boast_affinity_counter = 0; _boast_affinity_counter < _boast_affinity_cpu_number; _boast_affinity_counter++ )
+      for( _boast_affinity_counter = 0; _boast_affinity_counter < _boast_affinity_cpu_number; _boast_affinity_counter++ ) {
         CPU_SET(FIX2INT(rb_ary_entry(_boast_affinity_rb_ptr,_boast_affinity_counter)), &_boast_affinity_mask);
-      sched_getaffinity(getpid(), sizeof(_boast_affinity_mask_old), &_boast_affinity_mask_old);
-      if( sched_setaffinity(getpid(), sizeof(_boast_affinity_mask), &_boast_affinity_mask) != 0)
+      }
+      pthread_getaffinity_np(pthread_self(), sizeof(*_boast_affinity_mask_old), _boast_affinity_mask_old);
+      if( pthread_setaffinity_np(pthread_self(), sizeof(_boast_affinity_mask), &_boast_affinity_mask) != 0) {
         rb_raise(rb_eArgError, "Invalid affinity list provided!");
-      _boast_affinity_set = 1;
+      }
+      return 1;
     }
   }
+  return 0;
+}
+
+static int _boast_restore_affinity( int _boast_affinity_set, cpu_set_t * _boast_affinity_mask_old );
+static int _boast_restore_affinity( int _boast_affinity_set, cpu_set_t * _boast_affinity_mask_old ){
+  if ( _boast_affinity_set == 1 ) {
+    pthread_setaffinity_np(pthread_self(), sizeof(*_boast_affinity_mask_old), _boast_affinity_mask_old);
+  }
+  return 0;
+}
+
+EOF
+    end
+
+    def decl
+      get_output.puts "  cpu_set_t _boast_affinity_mask_old;"
+      get_output.puts "  int _boast_affinity_set;"
+    end
+
+    def configure
+      get_output.print <<EOF
+  _boast_affinity_set = _boast_affinity_setup( _boast_rb_opts, &_boast_affinity_mask_old);
 EOF
     end
 
@@ -54,16 +128,26 @@ EOF
 
     def compute
       get_output.print <<EOF
-  if ( _boast_affinity_set == 1 ) {
-    sched_setaffinity(getpid(), sizeof(_boast_affinity_mask_old), &_boast_affinity_mask_old);
-    _boast_affinity_set = 0;
-  }
+  _boast_affinity_set = _boast_restore_affinity( _boast_affinity_set, &_boast_affinity_mask_old);
 EOF
     end
 
     def store
     end
 
+    def is_available?
+      return false if OS.mac?
+      return true
+    end
+
+  end
+
+  if HwlocProbe.is_available?
+    AffinityProbe = HwlocProbe
+  elsif PthreadAffinityProbe.is_available?
+    AffinityProbe = PthreadAffinityProbe
+  else
+    AffinityProbe = nil
   end
 
 end

data/lib/BOAST/Runtime/CRuntime.rb

@@ -25,18 +25,30 @@ module BOAST
       get_output.write @code.read
     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}"
+        elsif param.direction == :out or param.direction == :inout or param.reference? 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}"
         elsif param.direction == :out or param.direction == :inout or param.reference? then
-          params.push( "&"+param.name )
+          "&#{par}"
         else
-          params.push( param.name )
+          "#{par}"
         end
       }
-      return params
     end
 
   end

data/lib/BOAST/Runtime/CUDARuntime.rb

@@ -13,6 +13,7 @@ module BOAST
     alias fill_decl_module_params_old fill_decl_module_params
     alias create_procedure_call_parameters_old create_procedure_call_parameters
     alias store_results_old store_results
+    alias create_wrapper_old create_wrapper
 
     def fill_module_header
       fill_module_header_old
@@ -49,7 +50,7 @@ extern "C" {
 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
@@ -58,8 +59,8 @@ 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];
-    cudaMalloc( (void **) &#{param}, _boast_array_size);
-    cudaMemcpy(#{param}, (void *) _boast_n_ary->ptr, _boast_array_size, cudaMemcpyHostToDevice);
+    cudaMalloc( (void **) &#{par}, _boast_array_size);
+    cudaMemcpy(#{par}, (void *) _boast_n_ary->ptr, _boast_array_size, cudaMemcpyHostToDevice);
   } else {
     rb_raise(rb_eArgError, "Wrong type of argument for %s, expecting array!", "#{param}");
   }
@@ -127,8 +128,11 @@ EOF
 EOF
     end
 
+    def create_wrapper
+    end
+
     def create_procedure_call_parameters
-      return create_procedure_call_parameters_old + ["_boast_block_number", "_boast_block_size", "_boast_repeat"]
+      return create_procedure_call_parameters_old + ["_boast_block_number", "_boast_block_size", "_boast_params._boast_repeat"]
     end
 
     def create_procedure_call
@@ -138,7 +142,7 @@ EOF
       get_output.puts " );"
     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
@@ -150,11 +154,11 @@ 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];
-    cudaMemcpy((void *) _boast_n_ary->ptr, #{param}, _boast_array_size, cudaMemcpyDeviceToHost);
+    cudaMemcpy((void *) _boast_n_ary->ptr, #{par}, _boast_array_size, cudaMemcpyDeviceToHost);
 EOF
       end
       get_output.print <<EOF
-    cudaFree( (void *) #{param});
+    cudaFree( (void *) #{par});
   } else {
     rb_raise(rb_eArgError, "Wrong type of argument for %s, expecting array!", "#{param}");
   }

data/lib/BOAST/Runtime/CoExecute.rb

@@ -0,0 +1,77 @@
+module BOAST
+
+  class CKernel
+
+    module Synchro
+      extend FFI::Library
+      ffi_lib 'pthread'
+      typedef :pointer, :mutex
+      typedef :pointer, :cond
+      typedef :pointer, :spin
+      attach_function 'pthread_mutex_init', [ :mutex, :pointer ], :int
+      attach_function 'pthread_mutex_destroy', [ :mutex ], :int
+      #attach_function 'pthread_mutex_lock', [ :mutex ], :int
+      #attach_function 'pthread_mutex_unlock', [ :mutex ], :int
+
+      attach_function 'pthread_cond_init', [ :cond, :pointer ], :int
+      attach_function 'pthread_cond_destroy', [ :cond ], :int
+      #attach_function 'pthread_cond_wait', [ :cond, :mutex ], :int
+      #attach_function 'pthread_cond_broadcast', [ :cond ], :int
+
+      begin
+        attach_function 'pthread_spin_init', [ :spin, :int ], :int
+        attach_function 'pthread_spin_destroy', [ :spin ], :int
+      rescue FFI::NotFoundError => e
+        warn "spin functions not found"
+      end
+    end
+
+    def self.coexecute(kernels)
+      semaphore = Mutex.new
+      pval = FFI::MemoryPointer::new(:int)
+      pval.write_int(kernels.length)
+      if synchro == 'MUTEX' then
+        mutex = FFI::MemoryPointer::new(128)
+        Synchro.pthread_mutex_init(mutex, nil)
+        condition = FFI::MemoryPointer::new(128)
+        Synchro.pthread_cond_init(mutex, nil)
+        sync = [pval, mutex, condition]
+      else
+        spinlock = FFI::MemoryPointer::new(128)
+        Synchro.pthread_spin_init(spinlock, 0)
+        sync = [pval, spinlock]
+      end
+      threads = []
+      returns = []
+      args = []
+      kernels.each_index { |i|
+        kernels[i][0].build unless kernels[i][0].methods.include?(:run)
+        args[i] = kernels[i][1].dup
+        if args[i].last.kind_of?( Hash ) then
+          args[i][-1] = args[i].last.dup
+          args[i][-1][:coexecute] = sync
+        else
+          args[i].push( { :coexecute => sync } )
+        end
+      }
+      kernels.each_index { |i|
+        threads << Thread::new(i) { |j|
+          ret = kernels[j][0].run(*args[j])
+          semaphore.synchronize {
+            returns[j] = ret
+          }
+        }
+      }
+      threads.each { |thr| thr.join }
+      if synchro == 'MUTEX' then
+        Synchro.pthread_mutex_destroy(mutex)
+        Synchro.pthread_cond_destroy(condition)
+      else
+        Synchro.pthread_spin_destroy(spinlock)
+      end
+      return returns
+    end
+
+  end
+
+end

data/lib/BOAST/Runtime/CompiledRuntime.rb

@@ -41,6 +41,7 @@ module BOAST
   module CompiledRuntime
     attr_accessor :binary
     attr_accessor :source
+    attr_reader :param_struct
 
     private
 
@@ -206,6 +207,9 @@ module BOAST
 #include "narray.h"
 #endif
 EOF
+      get_output.puts "#include <pthread.h>" unless executable?
+      get_output.puts "#include <sys/types.h>" unless executable?
+      get_output.puts "#include \"ruby/thread.h\"" unless executable?
       @includes.each { |inc|
         get_output.puts "#include \"#{inc}\""
       }
@@ -214,42 +218,25 @@ EOF
     def fill_module_preamble
       get_output.print <<EOF
 VALUE #{module_name} = Qnil;
+
+static VALUE method_run(int _boast_argc, VALUE *_boast_argv, VALUE _boast_self);
+
 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);
+  rb_define_method(#{module_name}, "__run", method_run, -1);
 }
-EOF
-    end
 
-    def fill_check_args
-      get_output.print <<EOF
-  VALUE _boast_rb_opts;
-  int _boast_repeat = 1;
-  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
+static VALUE _boast_check_get_options(int _boast_argc, VALUE *_boast_argv);
+static VALUE _boast_check_get_options(int _boast_argc, VALUE *_boast_argv) {
+  VALUE _boast_rb_opts = Qnil;
+  _boast_rb_opts = _boast_argv[_boast_argc -1];
+  return _boast_rb_opts;
+}
 
-    def add_run_options
-      get_output.print <<EOF
-  VALUE _boast_run_opts;
-  _boast_run_opts = rb_const_get(rb_cObject, rb_intern("BOAST"));
-  _boast_run_opts = rb_funcall(_boast_run_opts, rb_intern("get_run_config"), 0);
-  if ( NUM2UINT(rb_funcall(_boast_run_opts, rb_intern("size"), 0)) > 0 ) {
-    if ( _boast_rb_opts != Qnil )
-      rb_funcall(_boast_run_opts, rb_intern("update"), 1, _boast_rb_opts);
-    _boast_rb_opts = _boast_run_opts;
-  }
+static int _boast_get_repeat(VALUE _boast_rb_opts);
+static int _boast_get_repeat(VALUE _boast_rb_opts) {
+  int _boast_repeat = 1;
   if ( _boast_rb_opts != Qnil ){
     VALUE _boast_repeat_value = Qnil;
     _boast_repeat_value = rb_hash_aref(_boast_rb_opts, ID2SYM(rb_intern("repeat")));
@@ -258,25 +245,97 @@ EOF
     if(_boast_repeat < 0)
       _boast_repeat = 1;
   }
+  return _boast_repeat;
+}
+EOF
+
+    if !executable? then
+        get_output.print <<EOF
+struct _boast_synchro_struct {
+  volatile int * counter;
+EOF
+        if get_synchro == 'MUTEX' then
+          get_output.print <<EOF
+  pthread_mutex_t * mutex;
+  pthread_cond_t * condition;
+EOF
+        else
+          get_output.print <<EOF
+  pthread_spinlock_t * spin;
+EOF
+        end
+        get_output.print <<EOF
+};
+static int _boast_get_coexecute(VALUE _boast_rb_opts, struct _boast_synchro_struct * _boast_synchro);
+static int _boast_get_coexecute(VALUE _boast_rb_opts, struct _boast_synchro_struct * _boast_synchro) {
+  int _boast_coexecute = 0;
+  if ( _boast_rb_opts != Qnil ){
+    VALUE _boast_coexecute_value = Qnil;
+    _boast_coexecute_value = rb_hash_aref(_boast_rb_opts, ID2SYM(rb_intern("coexecute")));
+    if(_boast_coexecute_value != Qnil) {
+      VALUE address;
+      _boast_coexecute = 1;
+      address = rb_funcall(rb_ary_entry(_boast_coexecute_value, 0), rb_intern("address"), 0);
+      _boast_synchro->counter = sizeof(_boast_synchro->counter) == 4 ? (void *) NUM2ULONG(address) : (void *) NUM2ULL(address);
+EOF
+      if get_synchro == 'MUTEX' then
+        get_output.print <<EOF
+      address = rb_funcall(rb_ary_entry(_boast_coexecute_value, 1), rb_intern("address"), 0);
+      _boast_synchro->mutex = sizeof(_boast_synchro->mutex) == 4 ? (void *) NUM2ULONG(address) : (void *) NUM2ULL(address);
+      address = rb_funcall(rb_ary_entry(_boast_coexecute_value, 2), rb_intern("address"), 0);
+      _boast_synchro->condition = sizeof(_boast_synchro->condition) == 4 ? (void *) NUM2ULONG(address) : (void *) NUM2ULL(address);
+EOF
+      else
+        get_output.print <<EOF
+      address = rb_funcall(rb_ary_entry(_boast_coexecute_value, 1), rb_intern("address"), 0);
+      _boast_synchro->spin = sizeof(_boast_synchro->spin) == 4 ? (void *) NUM2ULONG(address) : (void *) NUM2ULL(address);
+EOF
+      end
+      get_output.print <<EOF
+    }
+  }
+  return _boast_coexecute;
+}
+
 EOF
+      end
+    end
+
+    def fill_check_args
+      get_output.print <<EOF
+  VALUE _boast_rb_opts = Qnil;
+  _boast_rb_opts = _boast_check_get_options( _boast_argc, _boast_argv);
+EOF
+    end
+
+    def add_run_options
+      get_output.print <<EOF
+  _boast_params._boast_repeat = _boast_get_repeat( _boast_rb_opts );
+EOF
+      get_output.puts "  _boast_params._boast_coexecute = _boast_get_coexecute( _boast_rb_opts, &_boast_params._boast_synchro );" unless executable?
+    end
+
+    def fill_param_struct
+      pars = @procedure.parameters.collect { |param|
+        param.copy(param.name, :const => nil, :constant => nil, :dir => nil, :direction => nil, :reference => nil )
+      }
+      pars.push @procedure.properties[:return].copy("_boast_ret") if @procedure.properties[:return]
+      pars.push Int("_boast_repeat")
+      pars.push Int("_boast_coexecute")
+      pars.push CStruct("_boast_timer", :type_name => "_boast_timer_struct", :members => [Int(:dummy)]) if @probes.include?(TimerProbe)
+      pars.push CStruct("_boast_synchro", :type_name => "_boast_synchro_struct", :members => [Int(:dummy)]) unless executable?
+      @param_struct = CStruct("_boast_params", :type_name => "_boast_#{@procedure.name}_params", :members => pars)
     end
 
     def fill_decl_module_params
       push_env(:decl_module => true) {
-        @procedure.parameters.each { |param|
-          param_copy = param.copy
-          param_copy.constant = nil
-          param_copy.direction = nil
-          param_copy.reference = nil
-          param_copy.decl
-        }
-        get_output.puts "  #{@procedure.properties[:return].type.decl} _boast_ret;" if @procedure.properties[:return]
+        param_struct.decl
         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|
+        @procedure.parameters.each { |param|
           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);"
@@ -284,26 +343,26 @@ EOF
       }
     end
 
-    def copy_scalar_param_from_ruby( param, ruby_param )
+    def copy_scalar_param_from_ruby(str_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
+        (str_par === FuncCall::new("NUM2INT", ruby_param)).pr if param.type.size == 4
+        (str_par === FuncCall::new("NUM2LONG", ruby_param)).pr if param.type.size == 8
       when Real
-        (param === FuncCall::new("NUM2DBL", ruby_param)).pr
+        (str_par === FuncCall::new("NUM2DBL", ruby_param)).pr
       end
     end
 
-    def copy_array_param_from_ruby( param, ruby_param )
+    def copy_array_param_from_ruby(str_par, 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) {
     #{
   if param.dimension then
-    "#{param} = (void *)RSTRING_PTR(_boast_rb_ptr)"
+    "#{str_par} = (void *)RSTRING_PTR(_boast_rb_ptr)"
   else
-    (param === param.copy("*(void *)RSTRING_PTR(_boast_rb_ptr)", :dimension => Dim(), :vector_length => 1)).to_s
+    (str_par === param.copy("*(void *)RSTRING_PTR(_boast_rb_ptr)", :dimension => Dim(), :vector_length => 1)).to_s
   end
     };
   } else if ( IsNArray(_boast_rb_ptr) ) {
@@ -311,13 +370,13 @@ EOF
     Data_Get_Struct(_boast_rb_ptr, struct NARRAY, _boast_n_ary);
     #{
   if param.dimension then
-    "#{param} = (void *) _boast_n_ary->ptr"
+    "#{str_par} = (void *) _boast_n_ary->ptr"
   else
-    (param === param.copy("*(void *) _boast_n_ary->ptr", :dimension => Dim(), :vector_length => 1)).to_s
+    (str_par === param.copy("*(void *) _boast_n_ary->ptr", :dimension => Dim(), :vector_length => 1)).to_s
   end
     };
   } else {
-    rb_raise(rb_eArgError, "Wrong type of argument for %s, expecting array!", "#{param}");
+    rb_raise(rb_eArgError, "Wrong type of argument for #{param}, expecting array!");
   }
 EOF
     end
@@ -328,81 +387,151 @@ EOF
       push_env(:decl_module => true) {
         @procedure.parameters.each_index do |i|
           param = @procedure.parameters[i]
-          if not param.dimension? and not param.vector? then
-            copy_scalar_param_from_ruby(param, argv[i])
+          par = param_struct.struct_reference(param_struct.type.members[param.name.to_s])
+          if param.dimension? or param.vector? then
+            copy_array_param_from_ruby(par, param, argv[i])
           else
-            copy_array_param_from_ruby(param, argv[i])
+            copy_scalar_param_from_ruby(par, param, argv[i])
           end
         end
       }
     end
 
-    def create_procedure_call
+    def create_wrapper
+      get_output.print <<EOF
+static void * boast_wrapper( void * data ) {
+  struct _boast_#{@procedure.name}_params * _boast_params;
+  _boast_params = data;
+EOF
+      if get_synchro == 'MUTEX' then
+        get_output.print <<EOF
+  pthread_mutex_lock(_boast_params->_boast_synchro.mutex);
+  *_boast_params->_boast_synchro.counter -= 1;
+  if( *_boast_params->_boast_synchro.counter == 0 ) {
+    pthread_cond_broadcast( _boast_params->_boast_synchro.condition );
+  }
+  while( *_boast_params->_boast_synchro.counter ) {
+    pthread_cond_wait( _boast_params->_boast_synchro.condition, _boast_params->_boast_synchro.mutex );
+  }
+  pthread_mutex_unlock(_boast_params->_boast_synchro.mutex);
+EOF
+      else
+        get_output.print <<EOF
+  pthread_spin_lock(_boast_params->_boast_synchro.spin);
+  *_boast_params->_boast_synchro.counter -= 1;
+  while( *_boast_params->_boast_synchro.counter ) {
+    pthread_spin_unlock(_boast_params->_boast_synchro.spin);
+    pthread_spin_lock(_boast_params->_boast_synchro.spin);
+  }
+  pthread_spin_unlock(_boast_params->_boast_synchro.spin);
+EOF
+      end
+      get_output.puts "  _boast_timer_start(&_boast_params->_boast_timer);" if @probes.include?(TimerProbe)
+      create_procedure_indirect_call
+      get_output.puts "  _boast_timer_stop(&_boast_params->_boast_timer);" if @probes.include?(TimerProbe)
+      get_output.print <<EOF
+  return NULL;
+}
+EOF
+    end
+
+    def create_procedure_wrapper_call
+      get_output.print <<EOF
+    rb_thread_call_without_gvl(boast_wrapper, &_boast_params, RUBY_UBF_PROCESS, NULL);
+EOF
+    end
+
+    def create_procedure_indirect_call
       get_output.puts  "  int _boast_i;"
-      get_output.puts  "  for(_boast_i = 0; _boast_i < _boast_repeat; ++_boast_i){"
-      get_output.print "    _boast_ret = " if @procedure.properties[:return]
-      get_output.print "    #{method_name}( "
-      get_output.print create_procedure_call_parameters.join(", ")
-      get_output.print "    );"
+      get_output.puts  "  for(_boast_i = 0; _boast_i < _boast_params->_boast_repeat; ++_boast_i){"
+      get_output.print "    "
+      get_output.print "_boast_params->_boast_ret = " if @procedure.properties[:return]
+      get_output.print "#{method_name}( "
+      get_output.print create_procedure_indirect_call_parameters.join(", ")
+      get_output.puts " );"
       get_output.puts  "  }"
     end
 
-    def copy_scalar_param_to_ruby(param, ruby_param)
+    def create_procedure_call
+      If("_boast_params._boast_coexecute" => lambda {
+        create_procedure_wrapper_call
+      }, :else => lambda {
+        TimerProbe.start if @probes.include?(TimerProbe)
+        get_output.puts  "    int _boast_i;"
+        get_output.puts  "    for(_boast_i = 0; _boast_i < _boast_params._boast_repeat; ++_boast_i){"
+        get_output.print "      "
+        get_output.print "_boast_params._boast_ret = " if @procedure.properties[:return]
+        get_output.print "#{method_name}( "
+        get_output.print create_procedure_call_parameters.join(", ")
+        get_output.puts " );"
+        get_output.puts  "    }"
+        TimerProbe.stop if @probes.include?(TimerProbe)
+      }).pr
+    end
+
+    def copy_scalar_param_to_ruby(str_par, 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?
+          if param.type.signed?
+            get_output.puts "  rb_hash_aset(_boast_refs, ID2SYM(rb_intern(\"#{param}\")),rb_int_new((long long)#{str_par}));"
+          else
+            get_output.puts "  rb_hash_aset(_boast_refs, ID2SYM(rb_intern(\"#{param}\")),rb_int_new((unsigned long long)#{str_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)#{str_par}));"
         end
       end
     end
 
-    def copy_scalar_param_to_file(param, base_path)
+    def copy_scalar_param_to_file(str_par, param, base_path)
       if param.scalar_output? then
         get_output.puts <<EOF
   __boast_f = fopen("#{base_path}/#{param}.out", "wb");
-  fwrite(&#{param}, sizeof(#{param}), 1, __boast_f);
+  fwrite(&(#{str_par}), sizeof(#{str_par}), 1, __boast_f);
   fclose(__boast_f);
 EOF
       end
     end
 
-    def copy_scalar_param_from_file(param, base_path)
+    def copy_scalar_param_from_file(str_par, param, base_path)
       get_output.puts <<EOF
   __boast_f = fopen("#{base_path}/#{param}.in", "rb");
-  fread(&#{param}, sizeof(#{param}), 1, __boast_f);
+  if( fread(&(#{str_par}), sizeof(#{str_par}), 1, __boast_f) != 1 ) {
+    exit(-1);
+  }
   fclose(__boast_f);
 EOF
     end
 
-    def copy_array_param_to_ruby(param, ruby_param)
+    def copy_array_param_to_ruby(str_par, param, ruby_param)
     end
 
-    def copy_array_param_to_file(param, base_path)
+    def copy_array_param_to_file(str_par, param, base_path)
       if param.direction == :out or param.direction == :inout then
         get_output.puts <<EOF
   __boast_f = fopen("#{base_path}/#{param}.out", "wb");
-  fwrite(#{param}, 1, __boast_sizeof_#{param}, __boast_f);
+  fwrite(#{str_par}, 1, __boast_sizeof_#{param}, __boast_f);
   fclose(__boast_f);
-  free(#{param});
+  free(#{str_par});
 EOF
       else
         get_output.puts <<EOF
-  free(#{param});
+  free(#{str_par});
 EOF
       end
     end
 
-    def copy_array_param_from_file(param, base_path)
+    def copy_array_param_from_file(str_par, param, base_path)
       get_output.puts <<EOF
   __boast_f = fopen("#{base_path}/#{param}.in", "rb");
   fseek(__boast_f, 0L, SEEK_END);
   __boast_sizeof_#{param} = ftell(__boast_f);
   rewind(__boast_f);
-  #{param} = malloc(__boast_sizeof_#{param});
-  fread(#{param}, 1, __boast_sizeof_#{param}, __boast_f);
+  #{str_par} = malloc(__boast_sizeof_#{param});
+  if( fread(#{str_par}, 1, __boast_sizeof_#{param}, __boast_f) != __boast_sizeof_#{param} ) {
+    exit(-1);
+  }
   fclose(__boast_f);
 EOF
     end
@@ -413,10 +542,11 @@ EOF
       push_env(: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])
+          par = param_struct.struct_reference(param_struct.type.members[param.name.to_s])
+          if param.dimension then
+            copy_array_param_to_ruby(par, param, argv[i])
           else
-            copy_array_param_to_ruby(param, argv[i])
+            copy_scalar_param_to_ruby(par, param, argv[i])
           end
         end
       }
@@ -425,19 +555,20 @@ EOF
     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)
+        get_output.puts "  rb_hash_aset(_boast_stats,ID2SYM(rb_intern(\"return\")),rb_int_new((long long)_boast_params._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_params._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_params._boast_ret));" if type_ret.kind_of?(Real)
       end
     end
 
     def get_executable_params_value( base_path )
       push_env(:decl_module => true) {
         @procedure.parameters.each do |param|
-          if not param.dimension? then
-            copy_scalar_param_from_file(param, base_path)
+          par = param_struct.struct_reference(param_struct.type.members[param.name.to_s])
+          if param.dimension? then
+            copy_array_param_from_file(par, param, base_path)
           else
-            copy_array_param_from_file(param, base_path)
+            copy_scalar_param_from_file(par, param, base_path)
           end
         end
       }
@@ -446,16 +577,18 @@ EOF
     def get_executable_params_return_value( base_path )
       push_env(:decl_module => true) {
         @procedure.parameters.each do |param|
-          if not param.dimension then
-            copy_scalar_param_to_file(param, base_path)
+          par = param_struct.struct_reference(param_struct.type.members[param.name.to_s])
+          if param.dimension then
+            copy_array_param_to_file(par, param, base_path)
           else
-            copy_array_param_to_file(param, base_path)
+            copy_scalar_param_to_file(par, param, base_path)
           end
         end
       }
     end
 
     def fill_executable_source
+      fill_param_struct
       get_output.puts "#include <inttypes.h>"
       get_output.puts "#include <stdlib.h>"
       get_output.puts "#include <stdio.h>"
@@ -464,28 +597,24 @@ EOF
       }
       @probes.map(&:header)
       @procedure.boast_header(@lang)
+      @probes.map(&:preamble)
 
+      param_struct.type.define
       get_output.print <<EOF
-void Init_#{base_name}( void );
-int _boast_repeat;
-void Init_#{base_name}( void ) {
+void Init_#{base_name}( int _boast_repeat );
+void Init_#{base_name}( int _boast_repeat ) {
 EOF
       increment_indent_level
       output.puts "  FILE * __boast_f;"
+      param_struct.decl
       push_env(:decl_module => true) {
         @procedure.parameters.each { |param|
           if param.dimension? then
             output.puts "  size_t __boast_sizeof_#{param};"
           end
-          param_copy = param.copy
-          param_copy.constant = nil
-          param_copy.direction = nil
-          param_copy.reference = nil
-          param_copy.decl
         }
-        get_output.puts "  #{@procedure.properties[:return].type.decl} _boast_ret;" if @procedure.properties[:return]
       }
-      @probes.reverse.map(&:decl)
+      @probes.reject{ |e| e ==TimerProbe }.reverse.map(&:decl)
       @probes.map(&:configure)
 
       get_executable_params_value( "#{@tmp_dir}/#{@procedure.name}/#{base_name}" )
@@ -495,7 +624,7 @@ EOF
       get_output.puts  "  int _boast_i;"
       get_output.puts  "  for(_boast_i = 0; _boast_i < _boast_repeat; ++_boast_i){"
       get_output.print "    "
-      get_output.print "_boast_ret = " if @procedure.properties[:return]
+      get_output.print "_boast_params._boast_ret = " if @procedure.properties[:return]
       get_output.print "#{method_name}( "
       get_output.print create_procedure_call_parameters.join(", ")
       get_output.puts  " );"
@@ -506,9 +635,9 @@ EOF
       get_output.puts '  printf("---\n");'
       if @procedure.properties[:return] then
         type_ret = @procedure.properties[:return].type
-        get_output.puts '  printf(":return: %lld\n", (long long)_boast_ret);' if type_ret.kind_of?(Int) and type_ret.signed
-        get_output.puts '  printf(":return: %ulld\n", (unsigned long long)_boast_ret);' if type_ret.kind_of?(Int) and not type_ret.signed
-        get_output.puts '  printf(":return: %lf\n", (double)_boast_ret);' if type_ret.kind_of?(Real)
+        get_output.puts '  printf(":return: %lld\n", (long long)_boast_params._boast_ret);' if type_ret.kind_of?(Int) and type_ret.signed
+        get_output.puts '  printf(":return: %ulld\n", (unsigned long long)_boast_params._boast_ret);' if type_ret.kind_of?(Int) and not type_ret.signed
+        get_output.puts '  printf(":return: %lf\n", (double)_boast_params._boast_ret);' if type_ret.kind_of?(Real)
 
       end
 
@@ -522,8 +651,7 @@ EOF
       get_output.print <<EOF
 }
 int main(int argc, char * argv[]) {
-  _boast_repeat=atoi(argv[1]);
-  Init_#{base_name}();
+  Init_#{base_name}(atoi(argv[1]));
   return 0;
 }
 EOF
@@ -544,33 +672,41 @@ EOF
     end
 
     def fill_module_file_source
+      fill_param_struct
       fill_module_header
       @probes.map(&:header)
       @procedure.boast_header(@lang)
 
       fill_module_preamble
+      @probes.map(&: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) {"
+
+      param_struct.type.define
+
+      create_wrapper
+
+      get_output.puts "static VALUE method_run(int _boast_argc, VALUE *_boast_argv, VALUE _boast_self) {"
+
       increment_indent_level
 
+      fill_decl_module_params
+
       fill_check_args
 
       add_run_options
 
-      fill_decl_module_params
-
-      @probes.reverse.map(&:decl)
+      @probes.reject{ |e| e == TimerProbe }.reverse.map(&:decl)
 
       get_params_value
 
       @probes.map(&:configure)
 
-      @probes.reverse.map(&:start)
+      @probes.reject{ |e| e == TimerProbe }.reverse.map(&:start)
 
       create_procedure_call
 
-      @probes.map(&:stop)
+      @probes.reject{ |e| e == TimerProbe }.map(&:stop)
 
       get_results
 
@@ -720,7 +856,7 @@ EOF
       elsif get_lang != CUDA then
         @probes = [TimerProbe, PAPIProbe]
         @probes.push EnergyProbe if EnergyProbe
-        @probes.push AffinityProbe unless OS.mac?
+        @probes.push AffinityProbe if AffinityProbe
       end
       @probes = [MPPAProbe] if @architecture == MPPA
       linker, ldshared, ldshared_flags, ldflags = setup_compilers(@probes, compiler_options)
@@ -748,6 +884,34 @@ EOF
 
       eval "self.extend(#{module_name})"
 
+      define_singleton_method(:run) { |*args, **options, &block|
+        raise "Wrong number of arguments for #{@procedure.name} (#{args.length} for #{@procedure.parameters.length})" if args.length != @procedure.parameters.length
+        config = BOAST::get_run_config
+        config.update(options)
+        res = nil
+        if get_lang != CUDA and config[:PAPI] then
+          require 'PAPI'
+          PAPI.init
+          if config[:coexecute] then
+            PAPI.thread_init
+          end
+        end
+        if AffinityProbe == HwlocProbe and config[:cpu_affinity] then
+          affinity = config[:cpu_affinity]
+          if affinity.kind_of?(Array) then
+            cpuset = Hwloc::Cpuset::new( affinity )
+          elsif affinity.kind_of?(Hwloc::Bitmap) then
+            cpuset = affinity
+          end
+          AffinityProbe.topology.set_cpubind(cpuset, Hwloc::CPUBIND_THREAD | Hwloc::CPUBIND_STRICT) {
+            res = __run(*args, config, &block)
+          }
+        else
+          res = __run(*args, config, &block)
+        end
+        res
+      }
+
       return self
     end