BOAST 0.99997 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb89f1443e6a90d1e3de87c5d9d6a23987b4c18a
-  data.tar.gz: c305d01f65fbdf595bb9a381589cd7220c67e5eb
+  metadata.gz: 88a3643b3adeeb4ba00c9e2531df8351c70739f0
+  data.tar.gz: ab54c2487d50cdd9683ce700ada7c4af6d36113c
 SHA512:
-  metadata.gz: a3a43dac0e6441cb2b1cc646bb40953974f861d5c8fb2e199ea60c517964c08eca4e20aba5a4831932b246cb1164633ca8d53196e3b77413bac0aa6eca7176d8
-  data.tar.gz: 94959453ffdf64b5e73429771eaaf1cc809369fd214be89668b51a27ae896554cdc053271af1877aa7ed4b42d5be1b4e3b116b9d5c9a6684f9467bffa7bfef89
+  metadata.gz: 898b0a5c86fde5ef320abcce81c9adb21a34ff0ce0b8d49acad2232b2f23d0e595a238140b3295070831f06f51a996280b6d5213f7e3d2dc37f3185a3ee0a515
+  data.tar.gz: 155796857e44a0456c4e2ae0549e69d8599d2ee5efa7803d8fc95a139d58d491eecb032dd89a4b24efaf3c76a06a66793ee9f610d0c5d20b39f882ea505e5bf3

data/BOAST.gemspec

@@ -1,9 +1,9 @@
 Gem::Specification.new do |s|
   s.name = 'BOAST'
-  s.version = "0.99997"
+  s.version = "1.0.1"
   s.author = "Brice Videau"
   s.email = "brice.videau@imag.fr"
-  s.homepage = "https://forge.imag.fr/projects/boast/"
+  s.homepage = "https://github.com/Nanosim-LIG/boast"
   s.summary = "BOAST is a computing kernel metaprogramming tool."
   s.description = "BOAST aims at providing a framework to metaprogram, benchmark and validate computing kernels"
   s.files = %w( BOAST.gemspec
@@ -42,4 +42,5 @@ Gem::Specification.new do |s|
   s.add_dependency 'narray', '>=0.6.0.8'
   s.add_dependency 'opencl_ruby_ffi', '>=0.4'
   s.add_dependency 'systemu', '>=2.2.0'
+  s.add_dependency 'PAPI', '>=0.101'
 end

data/lib/BOAST/CKernel.rb

@@ -37,9 +37,12 @@ module BOAST
 
   module PrivateStateAccessor
     private_boolean_state_accessor :verbose
+    private_boolean_state_accessor :ffi
   end
 
   boolean_state_accessor :verbose
+  boolean_state_accessor :ffi
+  @@ffi = false
   @@verbose = false
   FORTRAN_LINE_LENGTH = 72
 
@@ -77,6 +80,7 @@ module BOAST
     }
     @@compiler_default_options[:LD] = ENV["LD"] if ENV["LD"]
     @@verbose = ENV["VERBOSE"] if ENV["VERBOSE"]
+    @@ffi = ENV["FFI"] if ENV["FFI"]
   end
 
   read_boast_config
@@ -424,7 +428,18 @@ def self.run(*args)
   params.each_index{ |i|
     @kernel.set_arg(i, params[i])
   }
-  event = @queue.enqueue_NDrange_kernel(@kernel, opts[:global_work_size], :local_work_size => opts[:local_work_size])
+  gws = opts[:global_work_size]
+  if not gws then
+    gws = []
+    opts[:block_number].each_index { |i|
+      gws.push(opts[:block_number][i]*opts[:block_size][i])
+    }
+  end
+  lws = opts[:local_work_size]
+  if not lws then
+    lws = opts[:block_size]
+  end
+  event = @queue.enqueue_NDrange_kernel(@kernel, gws, :local_work_size => lws)
   @procedure.parameters.each_index { |i|
     if @procedure.parameters[i].dimension and (@procedure.parameters[i].direction == :inout or @procedure.parameters[i].direction == :out) then
       read_opencl_param( params[i], args[i], @procedure.parameters[i] )
@@ -468,7 +483,7 @@ EOF
       set_output( module_file )
       fill_module(module_file, module_name)
       module_file.rewind
-     #puts module_file.read
+      #puts module_file.read
       module_file.close
       set_lang( previous_lang )
       set_output( previous_output )
@@ -492,6 +507,83 @@ EOF
       return [source_file, path, target]
     end
 
+    def create_ffi_module(module_name, module_final)
+      s =<<EOF
+      require 'ffi'
+      require 'narray_ffi'
+      module #{module_name}
+        extend FFI::Library
+        ffi_lib "#{module_final}"
+        attach_function :#{@procedure.name}#{@lang == FORTRAN ? "_" : ""}, [ #{@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 = #{@procedure.name}#{@lang == FORTRAN ? "_" : ""}(*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
+      eval s
+    end
+
     def build(options = {})
       compiler_options = BOAST::get_compiler_options
       compiler_options.update(options)
@@ -503,28 +595,45 @@ EOF
 
       source_file, path, target = create_source
 
-      module_file_name, module_name = create_module_source(path)
-
-      module_target = module_file_name.chomp(File::extname(module_file_name))+".o"
-      module_final = module_file_name.chomp(File::extname(module_file_name))+".so"
-
+      if not ffi? then
+        module_file_name, module_name = create_module_source(path)
+        module_target = module_file_name.chomp(File::extname(module_file_name))+".o"
+        module_final = module_file_name.chomp(File::extname(module_file_name))+".so"
+      else
+        module_final = path.chomp(File::extname(path))+".so"
+        module_name = "Mod_" + File::split(path.chomp(File::extname(path)))[1].gsub("-","_")
+      end
 
       kernel_files = get_sub_kernels
 
-      file module_final => [module_target, target] do
-        #puts "#{linker} -shared -o #{module_final} #{module_target} #{target} #{kernel_files.join(" ")} -Wl,-Bsymbolic-functions -Wl,-z,relro -rdynamic -Wl,-export-dynamic #{ldflags}"
-        sh "#{linker} -shared -o #{module_final} #{module_target} #{target} #{(kernel_files.collect {|f| f.path}).join(" ")} -Wl,-Bsymbolic-functions -Wl,-z,relro -rdynamic -Wl,-export-dynamic #{ldflags}"
-      end
-      Rake::Task[module_final].invoke
+      if not ffi? then
+        file module_final => [module_target, target] do
+          #puts "#{linker} -shared -o #{module_final} #{module_target} #{target} #{kernel_files.join(" ")} -Wl,-Bsymbolic-functions -Wl,-z,relro -rdynamic -Wl,-export-dynamic #{ldflags}"
+          sh "#{linker} -shared -o #{module_final} #{module_target} #{target} #{(kernel_files.collect {|f| f.path}).join(" ")} -Wl,-Bsymbolic-functions -Wl,-z,relro -rdynamic -Wl,-export-dynamic #{ldflags}"
+        end
+        Rake::Task[module_final].invoke
 
-      require(module_final)
+        require(module_final)
+      else
+        file module_final => [target] do
+          #puts "#{linker} -shared -o #{module_final} #{target} #{kernel_files.join(" ")} -Wl,-Bsymbolic-functions -Wl,-z,relro -rdynamic -Wl,-export-dynamic #{ldflags}"
+          sh "#{linker} -shared -o #{module_final} #{target} #{(kernel_files.collect {|f| f.path}).join(" ")} -Wl,-Bsymbolic-functions -Wl,-z,relro -rdynamic -Wl,-export-dynamic #{ldflags}"
+        end
+        Rake::Task[module_final].invoke
+        create_ffi_module(module_name, module_final)
+      end
       eval "self.extend(#{module_name})"
-
       save_binary(target)
 
-      [target, module_target, module_file_name, module_final].each { |fn|
-        File::unlink(fn)
-      }
+      if not ffi? then
+        [target, module_target, module_file_name, module_final].each { |fn|
+          File::unlink(fn)
+        }
+      else
+        [target, module_final].each { |fn|
+          File::unlink(fn)
+        }
+      end
       kernel_files.each { |f|
         f.unlink
       }
@@ -598,7 +707,7 @@ EOF
       module_file.print <<EOF
 VALUE #{module_name} = Qnil;
 void Init_#{module_name}();
-VALUE method_run(int argc, VALUE *argv, VALUE self);
+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);
@@ -607,20 +716,23 @@ EOF
     end
 
     def check_args(module_file)
-      if @lang == CUDA then
-        module_file.print <<EOF
-  if( argc < #{@procedure.parameters.length} || argc > #{@procedure.parameters.length + 1} )
-    rb_raise(rb_eArgError, "wrong number of arguments for #{@procedure.name} (%d for #{@procedure.parameters.length})", argc);
-EOF
-      else
-        module_file.print <<EOF
-  if( argc != #{@procedure.parameters.length} )
-    rb_raise(rb_eArgError, "wrong number of arguments for #{@procedure.name} (%d for #{@procedure.parameters.length})", argc);
+      module_file.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
     end
 
     def get_params_value(module_file, argv, rb_ptr)
+      set_decl_module(true)
       @procedure.parameters.each_index do |i|
         param = @procedure.parameters[i]
         if not param.dimension then
@@ -635,30 +747,31 @@ EOF
           (rb_ptr === argv[i]).pr
           if @lang == CUDA then
             module_file.print <<EOF
-  if ( IsNArray(rb_ptr) ) {
-    struct NARRAY *n_ary;
-    size_t array_size;
-    Data_Get_Struct(rb_ptr, struct NARRAY, n_ary);
-    array_size = n_ary->total * na_sizeof[n_ary->type];
-    cudaMalloc( (void **) &#{param.name}, array_size);
-    cudaMemcpy(#{param.name}, (void *) n_ary->ptr, array_size, cudaMemcpyHostToDevice);
+  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];
+    cudaMalloc( (void **) &#{param.name}, _boast_array_size);
+    cudaMemcpy(#{param.name}, (void *) _boast_n_ary->ptr, _boast_array_size, cudaMemcpyHostToDevice);
   } else
     rb_raise(rb_eArgError, "wrong type of argument %d", #{i});
 EOF
           else
             module_file.print <<EOF
-  if (TYPE(rb_ptr) == T_STRING) {
-    #{param.name} = (void *) RSTRING_PTR(rb_ptr);
-  } else if ( IsNArray(rb_ptr) ) {
-    struct NARRAY *n_ary;
-    Data_Get_Struct(rb_ptr, struct NARRAY, n_ary);
-    #{param.name} = (void *) n_ary->ptr;
+  if (TYPE(_boast_rb_ptr) == T_STRING) {
+    #{param.name} = (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.name} = (void *) _boast_n_ary->ptr;
   } else
     rb_raise(rb_eArgError, "wrong type of argument %d", #{i});
 EOF
           end
         end
       end
+      set_decl_module(false)
     end
 
     def decl_module_params(module_file)
@@ -670,42 +783,60 @@ EOF
         param_copy.decl
       }
       set_decl_module(false)
-      module_file.print "  #{@procedure.properties[:return].type.decl} ret;\n" if @procedure.properties[:return]
-      module_file.print "  VALUE stats = rb_hash_new();\n"
-      module_file.print "  struct timespec start, stop;\n"
-      module_file.print "  unsigned long long int duration;\n"
+      module_file.print "  #{@procedure.properties[:return].type.decl} _boast_ret;\n" if @procedure.properties[:return]
+      module_file.print "  VALUE _boast_stats = rb_hash_new();\n"
+      module_file.print "  VALUE _boast_refs = rb_hash_new();\n"
+      module_file.print "  VALUE _boast_event_set = Qnil;\n"
+      module_file.print "  struct timespec _boast_start, _boast_stop;\n"
+      module_file.print "  unsigned long long int _boast_duration;\n"
     end
 
     def get_cuda_launch_bounds(module_file)
       module_file.print <<EOF
-  VALUE rb_opts;
-  size_t block_size[3] = {1,1,1};
-  size_t block_number[3] = {1,1,1};
-  if( argc == #{@procedure.parameters.length + 1} ) {
-    rb_opts = argv[argc -1];
-    if ( rb_opts != Qnil ) {
-      VALUE rb_array_data = Qnil;
-      int i;
-      if (TYPE(rb_opts) != T_HASH)
-        rb_raise(rb_eArgError, "Cuda options should be passed as a hash");
-      rb_ptr = rb_hash_aref(rb_opts, ID2SYM(rb_intern("block_size")));
-      if( rb_ptr != Qnil ) {
-        if (TYPE(rb_ptr) != T_ARRAY)
-          rb_raise(rb_eArgError, "Cuda option block_size should be an array");
-        for(i=0; i<3; i++) {
-          rb_array_data = rb_ary_entry(rb_ptr, i);
-          if( rb_array_data != Qnil )
-            block_size[i] = (size_t) NUM2LONG( rb_array_data );
+  size_t _boast_block_size[3] = {1,1,1};
+  size_t _boast_block_number[3] = {1,1,1};
+  if( _boast_rb_opts != Qnil ) {
+    VALUE _boast_rb_array_data = Qnil;
+    int _boast_i;
+    _boast_rb_ptr = rb_hash_aref(_boast_rb_opts, ID2SYM(rb_intern("block_size")));
+    if( _boast_rb_ptr != Qnil ) {
+      if (TYPE(_boast_rb_ptr) != T_ARRAY)
+        rb_raise(rb_eArgError, "Cuda option block_size should be an array");
+      for(_boast_i=0; _boast_i<3; _boast_i++) {
+        _boast_rb_array_data = rb_ary_entry(_boast_rb_ptr, _boast_i);
+        if( _boast_rb_array_data != Qnil )
+          _boast_block_size[_boast_i] = (size_t) NUM2LONG( _boast_rb_array_data );
+      }
+    } else {
+      _boast_rb_ptr = rb_hash_aref(_boast_rb_opts, ID2SYM(rb_intern("local_work_size")));
+      if( _boast_rb_ptr != Qnil ) {
+        if (TYPE(_boast_rb_ptr) != T_ARRAY)
+          rb_raise(rb_eArgError, "Cuda option local_work_size should be an array");
+        for(_boast_i=0; _boast_i<3; _boast_i++) {
+          _boast_rb_array_data = rb_ary_entry(_boast_rb_ptr, _boast_i);
+          if( _boast_rb_array_data != Qnil )
+            _boast_block_size[_boast_i] = (size_t) NUM2LONG( _boast_rb_array_data );
         }
       }
-      rb_ptr = rb_hash_aref(rb_opts, ID2SYM(rb_intern("block_number")));
-      if( rb_ptr != Qnil ) {
-        if (TYPE(rb_ptr) != T_ARRAY)
-          rb_raise(rb_eArgError, "Cuda option block_number should be an array");
-        for(i=0; i<3; i++) {
-          rb_array_data = rb_ary_entry(rb_ptr, i);
-          if( rb_array_data != Qnil )
-            block_number[i] = (size_t) NUM2LONG( rb_array_data );
+    }
+    _boast_rb_ptr = rb_hash_aref(_boast_rb_opts, ID2SYM(rb_intern("block_number")));
+    if( _boast_rb_ptr != Qnil ) {
+      if (TYPE(_boast_rb_ptr) != T_ARRAY)
+        rb_raise(rb_eArgError, "Cuda option block_number should be an array");
+      for(_boast_i=0; _boast_i<3; _boast_i++) {
+        _boast_rb_array_data = rb_ary_entry(_boast_rb_ptr, _boast_i);
+        if( _boast_rb_array_data != Qnil )
+          _boast_block_number[_boast_i] = (size_t) NUM2LONG( _boast_rb_array_data );
+      }
+    } else {
+      _boast_rb_ptr = rb_hash_aref(_boast_rb_opts, ID2SYM(rb_intern("global_work_size")));
+      if( _boast_rb_ptr != Qnil ) {
+        if (TYPE(_boast_rb_ptr) != T_ARRAY)
+          rb_raise(rb_eArgError, "Cuda option global_work_size should be an array");
+        for(_boast_i=0; _boast_i<3; _boast_i++) {
+          _boast_rb_array_data = rb_ary_entry(_boast_rb_ptr, _boast_i);
+          if( _boast_rb_array_data != Qnil )
+            _boast_block_number[_boast_i] = (size_t) NUM2LONG( _boast_rb_array_data ) / _boast_block_size[_boast_i];
         }
       }
     }
@@ -713,11 +844,45 @@ EOF
 EOF
     end
 
+    def  get_PAPI_options(module_file)
+module_file.print <<EOF
+  if( _boast_rb_opts != Qnil ) {
+    VALUE _boast_rb_array_data = Qnil;
+    _boast_rb_ptr = rb_hash_aref(_boast_rb_opts, ID2SYM(rb_intern("PAPI")));
+    if( _boast_rb_ptr != Qnil ) {
+      VALUE _boast_PAPI = Qnil;
+      VALUE _boast_EventSet = Qnil;
+      rb_require("PAPI");
+      _boast_PAPI =  rb_const_get(rb_cObject, rb_intern("PAPI"));
+      _boast_EventSet =  rb_const_get(_boast_PAPI, rb_intern("EventSet"));
+      _boast_event_set = rb_funcall(_boast_EventSet, rb_intern("new"), 0);
+      rb_funcall(_boast_event_set, rb_intern("add_named"), 1, _boast_rb_ptr);
+      rb_funcall(_boast_event_set, rb_intern("start"), 0);
+    }
+  }
+EOF
+    end
+
+    def get_PAPI_results(module_file)
+module_file.print <<EOF
+  if( _boast_event_set != Qnil) {
+    VALUE _boast_papi_results = Qnil;
+    VALUE _boast_papi_stats = Qnil;
+    _boast_papi_results = rb_funcall(_boast_event_set, rb_intern("stop"), 0);
+    _boast_papi_stats = rb_ary_new3(1,rb_hash_aref(_boast_rb_opts, ID2SYM(rb_intern("PAPI"))));
+    _boast_papi_stats = rb_funcall(_boast_papi_stats, rb_intern("flatten"), 0);
+    _boast_papi_stats = rb_funcall(_boast_papi_stats, rb_intern("zip"), 1, _boast_papi_results);
+    _boast_papi_stats = rb_funcall(rb_const_get(rb_cObject, rb_intern("Hash")), rb_intern("send"), 2, ID2SYM(rb_intern("[]")), _boast_papi_stats );
+    rb_hash_aset(_boast_stats,ID2SYM(rb_intern(\"PAPI\")),_boast_papi_stats);
+  }
+EOF
+    end
+
     def create_procedure_call(module_file)
       if @lang == CUDA then
-        module_file.print "  duration = "
+        module_file.print "  _boast_duration = "
       elsif @procedure.properties[:return] then
-        module_file.print "  ret = "
+        module_file.print "  _boast_ret = "
       end
       module_file.print "  #{@procedure.name}"
       module_file.print "_" if @lang == FORTRAN
@@ -744,28 +909,29 @@ EOF
         }
       end
       if @lang == CUDA then
-        params.push( "block_number", "block_size" )
+        params.push( "_boast_block_number", "_boast_block_size" )
       end
       module_file.print params.join(", ")
       module_file.print "  );\n"
     end
 
     def get_results(module_file, argv, rb_ptr)
+      set_decl_module(true)
       if @lang == CUDA then
         @procedure.parameters.each_index do |i|
           param = @procedure.parameters[i]
           if param.dimension then
             (rb_ptr === argv[i]).pr
             module_file.print <<EOF
-  if ( IsNArray(rb_ptr) ) {
+  if ( IsNArray(_boast_rb_ptr) ) {
 EOF
             if param.direction == :out or param.direction == :inout then
             module_file.print <<EOF
-    struct NARRAY *n_ary;
-    size_t array_size;
-    Data_Get_Struct(rb_ptr, struct NARRAY, n_ary);
-    array_size = n_ary->total * na_sizeof[n_ary->type];
-    cudaMemcpy((void *) n_ary->ptr, #{param.name}, array_size, cudaMemcpyDeviceToHost);
+    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];
+    cudaMemcpy((void *) _boast_n_ary->ptr, #{param.name}, _boast_array_size, cudaMemcpyDeviceToHost);
 EOF
             end
             module_file.print <<EOF
@@ -776,20 +942,38 @@ EOF
 EOF
           end
         end
+      else
+        first = true
+        @procedure.parameters.each_with_index do |param,i|
+          if param.scalar_output? then
+            if first then
+              module_file.print "  rb_hash_aset(_boast_stats,ID2SYM(rb_intern(\"reference_return\")),_boast_refs);\n"
+              first = false
+            end
+            case param.type
+            when Int
+              module_file.print "  rb_hash_aset(_boast_refs, ID2SYM(rb_intern(\"#{param}\")),rb_int_new((long long)#{param}));\n" if param.type.signed?
+              module_file.print "  rb_hash_aset(_boast_refs, ID2SYM(rb_intern(\"#{param}\")),rb_int_new((unsigned long long)#{param}));\n" if not param.type.signed?
+            when Real
+              module_file.print "  rb_hash_aset(_boast_refs, ID2SYM(rb_intern(\"#{param}\")),rb_float_new((double)#{param}));\n"
+            end
+          end
+        end
       end
+      set_decl_module(false)
     end
 
     def store_result(module_file)
       if @lang != CUDA then
-        module_file.print "  duration = (unsigned long long int)stop.tv_sec * (unsigned long long int)1000000000 + stop.tv_nsec;\n"
-        module_file.print "  duration -= (unsigned long long int)start.tv_sec * (unsigned long long int)1000000000 + start.tv_nsec;\n"
+        module_file.print "  _boast_duration = (unsigned long long int)_boast_stop.tv_sec * (unsigned long long int)1000000000 + _boast_stop.tv_nsec;\n"
+        module_file.print "  _boast_duration -= (unsigned long long int)_boast_start.tv_sec * (unsigned long long int)1000000000 + _boast_start.tv_nsec;\n"
       end
-      module_file.print "  rb_hash_aset(stats,ID2SYM(rb_intern(\"duration\")),rb_float_new((double)duration*(double)1e-9));\n"
+      module_file.print "  rb_hash_aset(_boast_stats,ID2SYM(rb_intern(\"duration\")),rb_float_new((double)_boast_duration*(double)1e-9));\n"
       if @procedure.properties[:return] then
         type_ret = @procedure.properties[:return].type
-        module_file.print "  rb_hash_aset(stats,ID2SYM(rb_intern(\"return\")),rb_int_new((long long)ret));\n" if type_ret.kind_of?(Int) and type_ret.signed
-        module_file.print "  rb_hash_aset(stats,ID2SYM(rb_intern(\"return\")),rb_int_new((unsigned long long)ret));\n" if type_ret.kind_of?(Int) and not type_ret.signed
-        module_file.print "  rb_hash_aset(stats,ID2SYM(rb_intern(\"return\")),rb_float_new((double)ret));\n" if type_ret.kind_of?(Real)
+        module_file.print "  rb_hash_aset(_boast_stats,ID2SYM(rb_intern(\"return\")),rb_int_new((long long)_boast_ret));\n" if type_ret.kind_of?(Int) and type_ret.signed
+        module_file.print "  rb_hash_aset(_boast_stats,ID2SYM(rb_intern(\"return\")),rb_int_new((unsigned long long)_boast_ret));\n" if type_ret.kind_of?(Int) and not type_ret.signed
+        module_file.print "  rb_hash_aset(_boast_stats,ID2SYM(rb_intern(\"return\")),rb_float_new((double)_boast_ret));\n" if type_ret.kind_of?(Real)
       end
     end
 
@@ -798,13 +982,13 @@ EOF
       @procedure.boast_header(@lang)
       module_preamble(module_file, module_name)
 
-      module_file.puts "VALUE method_run(int argc, VALUE *argv, VALUE self) {"
+      module_file.puts "VALUE method_run(int _boast_argc, VALUE *_boast_argv, VALUE _boast_self) {"
 
       check_args(module_file)
 
       argc = @procedure.parameters.length
-      argv = Variable::new("argv", CustomType, :type_name => "VALUE", :dimension => [ Dimension::new(0,argc-1) ] )
-      rb_ptr = Variable::new("rb_ptr", CustomType, :type_name => "VALUE")
+      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_transition("VALUE", "VALUE", :default,  CustomType::new(:type_name => "VALUE"))
       rb_ptr.decl
 
@@ -816,17 +1000,21 @@ EOF
         module_file.print get_cuda_launch_bounds(module_file)
       end
 
-      module_file.print "  clock_gettime(CLOCK_REALTIME, &start);\n"
+      get_PAPI_options(module_file)
+
+      module_file.print "  clock_gettime(CLOCK_REALTIME, &_boast_start);\n"
 
       create_procedure_call(module_file)
 
-      module_file.print "  clock_gettime(CLOCK_REALTIME, &stop);\n"
+      module_file.print "  clock_gettime(CLOCK_REALTIME, &_boast_stop);\n"
+
+      get_PAPI_results(module_file)
 
       get_results(module_file, argv, rb_ptr)
 
       store_result(module_file)
 
-      module_file.print "  return stats;\n"
+      module_file.print "  return _boast_stats;\n"
       module_file.print "}"
     end
 

data/lib/BOAST/DataTypes.rb

@@ -45,6 +45,10 @@ module BOAST
       end
     end
 
+    def decl_ffi
+      return :size_t
+    end
+
     def signed?
       return !!signed
     end
@@ -133,6 +137,11 @@ module BOAST
       end
     end
 
+    def decl_ffi
+      return :float if @size == 4
+      return :double if @size == 8
+    end
+
     def suffix
       s = ""
       if [C, CL, CUDA].include?( lang ) then
@@ -176,6 +185,7 @@ module BOAST
 #          @getters["s#{indx}"] = indx
 #          @setters["s#{indx}="] = indx
 #        }
+         raise "Vectors need to have their element size specified!" if not @size
       else
         @vector_length = 1
       end
@@ -199,12 +209,16 @@ module BOAST
     end
 
     def decl
-      return "integer(kind=#{@size})" if lang == FORTRAN
+      if lang == FORTRAN then
+        return "integer(kind=#{@size})" if @size
+        return "integer"
+      end
       if lang == C then
         if @vector_length == 1 then
           s = ""
           s += "u" if not @signed
-          return s+"int#{8*@size}_t"
+          return s+"int#{8*@size}_t" if @size
+          return s+"int"
         elsif @vector_length > 1 then
           if get_architecture == X86 then
             return "__m#{@total_size*8}#{@total_size*8>64 ? "i" : ""}"
@@ -228,6 +242,8 @@ module BOAST
           char += "int"
         when 8
           char += "long"
+        when nil
+          char += "int"
         else
           raise "Unsupported integer size!"
         end
@@ -248,6 +264,8 @@ module BOAST
             char += "int"
           when 8
             char += "longlong"
+          when nil
+            char += "int"
           else
             raise "Unsupported integer size!"
           end
@@ -255,14 +273,33 @@ module BOAST
         else
           char = ""
           char += "unsigned " if not @signed
-          return char += "char" if @size==1
-          return char += "short" if @size==2
-          return char += "int" if @size==4
-          return char += "long long" if @size==8
+          case @size
+          when 1
+            char += "char"
+          when 2
+            char += "short"
+          when 4
+            char += "int"
+          when 8
+            char += "longlong"
+          when nil
+            char += "int"
+          else
+            raise "Unsupported integer size!"
+          end
+          return char
         end
       end
     end
 
+    def decl_ffi
+      t = ""
+      t += "u" if not @signed
+      t += "int"
+      t += "#{@size*8}" if @size
+      return t.to_sym
+    end
+
     def suffix
       s = ""
       return s

data/lib/BOAST/Procedure.rb

@@ -79,6 +79,15 @@ module BOAST
       return close_c if [C, CL, CUDA].include?( lang )
     end
 
+    def ckernel
+      old_output = output
+      k = CKernel::new
+      k.procedure = self
+      self.pr
+      set_output( old_output )
+      return k
+    end
+
     def close_c
       decrement_indent_level
       s = ""

data/lib/BOAST/Variable.rb

@@ -26,6 +26,8 @@ module BOAST
     def to_s
       if lang == FORTRAN and @val2 then
         return "#{@val1}:#{@val2}"
+      elsif lang == FORTRAN and get_array_start != 1 then
+        return "#{get_array_start}:#{@size-(1+get_array_start)}"
       else
         return @size
       end 
@@ -169,6 +171,10 @@ module BOAST
       !!@dimension
     end
 
+    def scalar_output?
+      !!@scalar_output
+    end
+
     def initialize(name,type,hash={})
       @name = name.to_s
       @direction = hash[:direction] ? hash[:direction] : hash[:dir]
@@ -223,7 +229,7 @@ module BOAST
         s = @constant.to_s + @type.suffix
         return s
       end
-      if @scalar_output and [C, CL, CUDA].include?( lang ) then
+      if @scalar_output and [C, CL, CUDA].include?( lang ) and not decl_module? then
         return "(*#{name})"
       end
       return @name
@@ -290,6 +296,13 @@ module BOAST
       return s
     end
 
+    def decl_ffi(alloc = false)
+      return :pointer if lang == FORTRAN and not alloc
+      return :pointer if dimension?
+      return :pointer if @direction == :out or @direction == :inout and not alloc
+      return @type.decl_ffi
+    end
+
     def decl
       return decl_fortran if lang == FORTRAN
       return decl_c if [C, CL, CUDA].include?( lang )

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: BOAST
 version: !ruby/object:Gem::Version
-  version: '0.99997'
+  version: 1.0.1
 platform: ruby
 authors:
 - Brice Videau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-26 00:00:00.000000000 Z
+date: 2015-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: narray
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.2.0
+- !ruby/object:Gem::Dependency
+  name: PAPI
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.101'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.101'
 description: BOAST aims at providing a framework to metaprogram, benchmark and validate
   computing kernels
 email: brice.videau@imag.fr
@@ -88,7 +102,7 @@ files:
 - lib/BOAST/Transitions.rb
 - lib/BOAST/Variable.rb
 - lib/BOAST/While.rb
-homepage: https://forge.imag.fr/projects/boast/
+homepage: https://github.com/Nanosim-LIG/boast
 licenses:
 - BSD
 metadata: {}