BOAST 1.3.2 → 1.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ce1471079358a166a828d428d014c785ac0a6b08
-  data.tar.gz: a9b317526e6589ee928c41fa4f78b469a0d0a1b7
+  metadata.gz: '0018ca6c7cd0bb34a289e2bca33368e17dc80f39'
+  data.tar.gz: ddb3f445eb1115dc1d095dae2f9e6b8d418e6e66
 SHA512:
-  metadata.gz: ff7690a6d81dd4d1b1c258d65da70ea326532a2968c618f471c83faf8ddb21dab9602156a6b495f06aca1cc3adfcd7bf0b76a6f4b32aa3983e182b0a535f8f45
-  data.tar.gz: 27107abb8e7166fac2593b2e78b5275f44bcbf54be4b065d2c024cf9ab6e9b5070bb971fdf09b39a491aafe1b4cf4a41aeebcfc96f91c43c891f8f688cef2fb1
+  metadata.gz: bf37152987945905a54ae8d267d5c657724caa6f74fb694a99be6ed9ccb4a773fa62b3881273c376c96a2909b14635ea05399fed4270360806d8c6029c6e7b1d
+  data.tar.gz: '098705bf24623a96a9ad8368b6644fb4b6c3b9f24636ffbdef10f23f589c247d13f88e34a8b5c87c35cc52c86dca5842b20536d875b0796e22c5a957fb46cd6d'

data/BOAST.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'BOAST'
-  s.version = "1.3.2"
+  s.version = "1.3.3"
   s.author = "Brice Videau"
   s.email = "brice.videau@imag.fr"
   s.homepage = "https://github.com/Nanosim-LIG/boast"

data/lib/BOAST.rb

@@ -30,6 +30,8 @@ require 'BOAST/Language/Pragma.rb'
 require 'BOAST/Runtime/Config.rb'
 require 'BOAST/Runtime/Probe.rb'
 require 'BOAST/Runtime/AffinityProbe.rb'
+require 'BOAST/Runtime/EnergyProbe.rb'
+require 'BOAST/Runtime/Temperature.rb'
 require 'BOAST/Runtime/Compilers.rb'
 require 'BOAST/Runtime/OpenCLRuntime.rb'
 require 'BOAST/Runtime/CompiledRuntime.rb'
@@ -41,6 +43,7 @@ require 'BOAST/Runtime/FFIRuntime.rb'
 require 'BOAST/Runtime/MPPARuntime.rb'
 require 'BOAST/Runtime/CKernel.rb'
 require 'BOAST/Runtime/NonRegression.rb'
+require 'BOAST/Runtime/RubyEnergyMonitor.rb'
 require 'BOAST/Language/Parens.rb'
 require 'BOAST/Language/BOAST_OpenCL.rb'
 require 'BOAST/Optimization/Optimization.rb'

data/lib/BOAST/Language/Operators.rb

@@ -412,7 +412,7 @@ module BOAST
             end
             return @return_type.copy("vload#{@return_type.type.vector_length}(0, #{a2})", DISCARD_OPTIONS) if lang == CL
             return @return_type.copy("_m_from_int64( *((int64_t * ) #{a2} ) )", DISCARD_OPTIONS) if get_architecture == X86 and @return_type.type.total_size*8 == 64
-            if @source.alignment == @return_type.type.total_size then
+            if @source.alignment and @return_type.type.total_size and ( @source.alignment % @return_type.type.total_size ) == 0 then
               instruction = intrinsics(:LOADA, @return_type.type)
             else
               instruction = intrinsics(:LOAD, @return_type.type)
@@ -536,7 +536,7 @@ module BOAST
         return "vstore#{type.vector_length}( #{@source}, 0, #{dst} )" if lang == CL
         return "*((int64_t * ) #{dst}) = _m_to_int64( #{@source} )" if get_architecture == X86 and type.total_size*8 == 64
 
-        if @dest.alignment == type.total_size then
+        if @dest.alignment and type.total_size and ( @dest.alignment % type.total_size ) == 0 then
           instruction = intrinsics(:STOREA, type)
         else
           instruction = intrinsics(:STORE, type)

data/lib/BOAST/Language/Procedure.rb

@@ -20,6 +20,7 @@ module BOAST
     # @param [Hash] properties set of named properties for the Procedure.
     # @option properties [Array<Variables>] :constants list of constant variables that are used in the Procedure. (see parameter in Fortran).
     # @option properties [Array<#to_s>] :headers list of headers that need to be included in order to compile the Procedure
+    # @option propertirs [Variable] :return a Variable that will be returned. Procedure becomes a function, return type is the same as the returned variable. The variable will be declared at the start of the procedure.
     def initialize(name, parameters=[], properties={}, &block)
       @name = name
       @parameters = parameters
@@ -269,7 +270,7 @@ module BOAST
       end
       if lang == CUDA then
         s += ", " if parameters.first
-        s += "size_t *block_number, size_t *block_size"
+        s += "size_t *_boast_block_number, size_t *_boast_block_size, int _boast_repeat"
       end
       s += ")"
       return s

data/lib/BOAST/Runtime/CKernel.rb

@@ -55,8 +55,6 @@ module BOAST
       else
         @architecture = get_architecture
       end
-      @probes = [TimerProbe, PAPIProbe]
-      @probes.push AffinityProbe unless OS.mac?
 
       case @lang
       when CL
@@ -70,7 +68,6 @@ module BOAST
       else
         if @architecture == MPPA then
           extend MPPARuntime
-          @probes = [MPPAProbe]
         else
           extend CRuntime
           extend FFIRuntime if ffi?

data/lib/BOAST/Runtime/CUDARuntime.rb

@@ -29,14 +29,16 @@ module BOAST
       get_output.write <<EOF
 extern "C" {
   #{@procedure.send(:boast_header_s,CUDA)}{
-    dim3 dimBlock(block_size[0], block_size[1], block_size[2]);
-    dim3 dimGrid(block_number[0], block_number[1], block_number[2]);
+    dim3 dimBlock(_boast_block_size[0], _boast_block_size[1], _boast_block_size[2]);
+    dim3 dimGrid(_boast_block_number[0], _boast_block_number[1], _boast_block_number[2]);
     cudaEvent_t __start, __stop;
     float __time;
     cudaEventCreate(&__start);
     cudaEventCreate(&__stop);
     cudaEventRecord(__start, 0);
-    #{@procedure.name}<<<dimGrid,dimBlock>>>(#{@procedure.parameters.join(", ")});
+    for( int _boast_i = 0; _boast_i < _boast_repeat; _boast_i ++) {
+      #{@procedure.name}<<<dimGrid,dimBlock>>>(#{@procedure.parameters.join(", ")});
+    }
     cudaEventRecord(__stop, 0);
     cudaEventSynchronize(__stop);
     cudaEventElapsedTime(&__time, __start, __stop);
@@ -125,7 +127,7 @@ EOF
     end
 
     def create_procedure_call_parameters
-      return create_procedure_call_parameters_old + ["_boast_block_number", "_boast_block_size"]
+      return create_procedure_call_parameters_old + ["_boast_block_number", "_boast_block_size", "_boast_repeat"]
     end
 
     def create_procedure_call

data/lib/BOAST/Runtime/CompiledRuntime.rb

@@ -179,6 +179,7 @@ EOF
     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;
@@ -202,6 +203,14 @@ EOF
       rb_funcall(_boast_run_opts, rb_intern("update"), 1, _boast_rb_opts);
     _boast_rb_opts = _boast_run_opts;
   }
+  if ( _boast_rb_opts != Qnil ){
+    VALUE _boast_repeat_value = Qnil;
+    _boast_repeat_value = rb_hash_aref(_boast_rb_opts, ID2SYM(rb_intern("repeat")));
+    if(_boast_repeat_value != Qnil)
+      _boast_repeat = NUM2UINT(_boast_repeat_value);
+    if(_boast_repeat < 0)
+      _boast_repeat = 1;
+  }
 EOF
     end
 
@@ -270,10 +279,12 @@ EOF
     end
 
     def create_procedure_call
-      get_output.print "  _boast_ret = " if @procedure.properties[:return]
-      get_output.print " #{method_name}( "
+      get_output.puts  "  for(int _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.puts " );"
+      get_output.print "    );"
+      get_output.puts  "  }"
     end
 
     def copy_scalar_param_to_ruby(param, ruby_param)
@@ -400,6 +411,15 @@ EOF
       compiler_options.update(options)
       linker, ldshared, ldflags = setup_compilers(compiler_options)
       @compiler_options = compiler_options
+      @probes = []
+      if @compiler_options[:probes] then
+        @probes = @compiler_options[:probes]
+      elsif get_lang != CUDA
+        @probes = [TimerProbe, PAPIProbe]
+        @probes.push EnergyProbe if EnergyProbe
+        @probes.push AffinityProbe unless OS.mac?
+      end
+      @probes = [MPPAProbe] if @architecture == MPPA
 
       @marker = Tempfile::new([@procedure.name,""])
 

data/lib/BOAST/Runtime/Config.rb

@@ -19,7 +19,8 @@ module BOAST
     :CLDEVICETYPE => nil,
     :MAQAO => 'maqao',
     :MAQAO_FLAGS => '',
-    :OPENMP => false
+    :OPENMP => false,
+    :probes => nil
   }
   
   @@openmp_default_flags = {

data/lib/BOAST/Runtime/EnergyProbe.rb

@@ -0,0 +1,231 @@
+module BOAST
+  module PowercapProbe
+    extend PrivateStateAccessor
+    module_function
+    def header
+      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
+      get_output.print <<EOF
+{
+  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);
+
+  for(nproc = 0; ; ++nproc){
+    sprintf(path,"/sys/devices/virtual/powercap/intel-rapl/intel-rapl:%d",nproc);
+    sprintf(buf,"%s/energy_uj",path);
+    f = fopen(buf, "rt");
+    if(!f)
+      break;
+    i = 0;
+    do{
+      int _boast_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);
+      sprintf(buf, "%s/name", path);
+      f = fopen(buf, "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!");
+      /* last character read is a line break */
+      buf[_boast_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);
+  }
+  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));
+  }
+}
+EOF
+    end
+    def start
+      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_0[i] = atoll(buf);
+  }
+}
+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);
+  }
+}
+EOF
+    end
+    def compute
+      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);
+}
+EOF
+    end
+    def is_available
+      [] != Dir.glob( '/sys/class/powercap/intel-rapl:0:0' )
+    end
+  end
+
+  module RedfstProbe
+    extend PrivateStateAccessor
+    module_function
+    def header
+      get_output.puts "#include <redfst.h>"
+    end
+    def decl
+      get_output.puts "redfst_dev_t *_boast_energy=0;"
+    end
+    def configure
+      get_output.puts "redfst_init();"
+    end
+    def start
+      get_output.puts "redfst_reset();"
+    end
+    def stop
+      get_output.puts "_boast_energy = redfst_get(_boast_energy);"
+    end
+    def compute
+      get_output.print <<EOF
+{
+  VALUE results;
+  double pkg, pp0, dram;
+  char *s;
+  int i;
+  pkg = pp0 = dram = 0;
+  results = rb_hash_new();
+  for(i=0; i < _boast_energy->count; ++i){
+    rb_hash_aset(results, ID2SYM(rb_intern(_boast_energy->name[i])), rb_float_new(_boast_energy->energy[i]));
+    s = _boast_energy->name[i];
+    while('.'!=*s++)
+      ;
+    while('.'!=*s++)
+      ;
+    if(!strcmp("pkg",s))
+      pkg += _boast_energy->energy[i];
+    else if(!strcmp("pp0",s))
+      pp0 += _boast_energy->energy[i];
+    else if(!strcmp("dram",s))
+      dram += _boast_energy->energy[i];
+  }
+  rb_hash_aset(results, ID2SYM(rb_intern("total.pkg" )), rb_float_new(pkg));
+  rb_hash_aset(results, ID2SYM(rb_intern("total.pp0" )), rb_float_new(pp0));
+  rb_hash_aset(results, ID2SYM(rb_intern("total.dram")), rb_float_new(dram));
+  rb_hash_aset(results, ID2SYM(rb_intern("total"     )), rb_float_new(pkg+dram));
+  rb_hash_aset(_boast_stats, ID2SYM(rb_intern("energy")), results);
+}
+EOF
+		end
+    def is_available
+      [] != ENV['LIBRARY_PATH'].split(':').inject([]){|mem, x| []!=mem ? mem : Dir.glob(x+'/libredfst.so')}
+    end
+  end
+
+  module EmlProbe
+    extend PrivateStateAccessor
+    module_function
+    def header
+      get_output.puts "#include <eml.h>"
+    end
+    def decl
+      get_output.puts "emlData_t **_boast_energy=0;";
+      get_output.puts "size_t _boast_energy_count=0;";
+    end
+    def configure
+      get_output.puts "emlInit();"
+      get_output.puts "emlDeviceGetCount(&_boast_energy_count);"
+      get_output.puts "_boast_energy = malloc(_boast_energy_count*sizeof(*_boast_energy));"
+    end
+    def start
+      get_output.puts "emlStart();";
+    end
+    def stop
+      get_output.puts "emlStop(_boast_energy);";
+    end
+    def compute
+      get_output.print <<EOF
+{
+  VALUE results;
+  double consumed;
+  results = rb_hash_new();
+  emlDataGetConsumed(_boast_energy[0], &consumed);
+  rb_hash_aset(results, ID2SYM(rb_intern("total" )), rb_float_new(consumed));
+  rb_hash_aset(_boast_stats, ID2SYM(rb_intern("energy")), results);
+}
+EOF
+    end
+    def is_available
+      [] != ENV['LIBRARY_PATH'].split(':').inject([]){|mem, x| []!=mem ? mem : Dir.glob(x+'/libeml.so')}
+    end
+  end
+  if PowercapProbe.is_available
+    EnergyProbe = PowercapProbe
+  elsif RedfstProbe.is_available
+    EnergyProbe = RedfstProbe
+  elsif EmlProbe.is_available
+    EnergyProbe = EmlProbe
+  else
+    EnergyProbe = nil
+  end
+end

data/lib/BOAST/Runtime/OpenCLRuntime.rb

@@ -124,11 +124,13 @@ module BOAST
     def build(options={})
       compiler_options = BOAST::get_compiler_options
       compiler_options.update(options)
+      @probes = compiler_options[:probes] if compiler_options[:probes]
       init_opencl(compiler_options)
 
       run_method = <<EOF
 def self.run(*args)
   raise "Wrong number of arguments \#{args.length} for #{@procedure.parameters.length}" if args.length > #{@procedure.parameters.length+1} or args.length < #{@procedure.parameters.length}
+  energy_data = NArray::float(1024)
   params = []
   opts = BOAST::get_run_config
   opts = opts.update(args.pop) if args.length == #{@procedure.parameters.length+1}

data/lib/BOAST/Runtime/RubyEnergyMonitor.rb

@@ -0,0 +1,46 @@
+module BOAST
+if false
+  module OpenCLRuntime
+
+    st = BOAST::get_output
+
+    p = BOAST::Procedure("energy_kernel_init",[])
+    ENERGY_PROBE_INIT = BOAST::CKernel::new( :lang => C )
+    ENERGY_PROBE_INIT.procedure = p
+    BOAST::get_output.print <<EOF
+#include <redfst.h>
+void energy_kernel_init(void) {
+  redfst_init();
+}
+EOF
+
+    p = BOAST::Procedure("energy_kernel_start",[])
+    ENERGY_PROBE_START = BOAST::CKernel::new( :lang => C )
+    ENERGY_PROBE_START.procedure = p
+    BOAST::get_output.print <<EOF
+#include <redfst.h>
+void energy_kernel_start(void) {
+  redfst_reset();
+}
+EOF
+
+    p = BOAST::Procedure("energy_reading_kernel",[BOAST::Real("data",:dim => BOAST::Dim(),:dir => :out)], [], :return => BOAST::Int("nb_cpus") )
+    ENERGY_PROBE_STOP = BOAST::CKernel::new( :lang => C )
+    ENERGY_PROBE_STOP.procedure = p
+    BOAST::get_output.print <<EOF
+#include <redfst.h>
+int energy_reading_kernel( double * data) {
+  redfst_get_all(data);
+  return redfst_ncpus();
+}
+EOF
+
+    ENERGY_PROBE_INIT.build( :LDFLAGS => '-lredfst -lm -lcpufreq' )
+    ENERGY_PROBE_START.build( :LDFLAGS => '-lredfst -lm -lcpufreq' )
+    ENERGY_PROBE_STOP.build( :LDFLAGS => '-lredfst -lm -lcpufreq' )
+
+    BOAST::set_output(st)
+
+  end
+end
+end

data/lib/BOAST/Runtime/Temperature.rb

@@ -0,0 +1,58 @@
+module BOAST
+  module Temperature
+    extend PrivateStateAccessor
+    module_function
+
+    def get
+      r = {}
+      Dir.glob("/sys/devices/platform/coretemp.*") {|dir|
+        cpu = dir.match(/[0-9]*$/)[0].to_i
+        r[cpu] = {}
+        Dir.glob(dir+'/hwmon/hwmon*/temp*_input') {|fname|
+          sensor = fname.match(/temp([0-9]+)_input$/)[1].to_i - 1
+          f = File.open(fname, 'r')
+          r[cpu][sensor] = f.read.to_i
+          f.close
+        }
+      }
+      return r
+    end
+
+    def set min_temps=nil
+      return if nil==min_temps
+      now = []
+      self.get.each{ |x,y| now.push y[0] }
+      nthreads = 2* (self.get[0].length-1) * self.get.length
+      fin = true
+      (0...now.length).each {|i|
+        fin = false if now[i] < min_temps[i]
+      }
+      return if fin
+      p = Array.new
+      (0...nthreads).each{|x| p.push fork{self.busy}}
+      while true
+        now = []
+        self.get.each{ |x,y| now.push y[0] }
+        fin = true
+        (0...now.length).each {|i|
+          fin = false if now[i] < min_temps[i]
+        }
+        break if fin
+      end
+      p.each {|x| Process.kill "KILL",x}
+      p.each {|x|
+        begin
+          Process.wait x
+        rescue Errno::ECHILD
+        end
+      }
+    end
+
+    def busy
+      while true
+        4.2 / 2.78
+      end
+    end
+
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: BOAST
 version: !ruby/object:Gem::Version
-  version: 1.3.2
+  version: 1.3.3
 platform: ruby
 authors:
 - Brice Videau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-25 00:00:00.000000000 Z
+date: 2016-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: narray
@@ -235,6 +235,7 @@ files:
 - lib/BOAST/Runtime/CompiledRuntime.rb
 - lib/BOAST/Runtime/Compilers.rb
 - lib/BOAST/Runtime/Config.rb
+- lib/BOAST/Runtime/EnergyProbe.rb
 - lib/BOAST/Runtime/FFIRuntime.rb
 - lib/BOAST/Runtime/FORTRANRuntime.rb
 - lib/BOAST/Runtime/MAQAO.rb
@@ -243,6 +244,8 @@ files:
 - lib/BOAST/Runtime/OpenCLRuntime.rb
 - lib/BOAST/Runtime/OpenCLTypes.rb
 - lib/BOAST/Runtime/Probe.rb
+- lib/BOAST/Runtime/RubyEnergyMonitor.rb
+- lib/BOAST/Runtime/Temperature.rb
 homepage: https://github.com/Nanosim-LIG/boast
 licenses:
 - BSD-2-Clause