BOAST 1.0.3 → 1.0.4

data/lib/BOAST/Runtime/NonRegression.rb

@@ -0,0 +1,157 @@
+module BOAST
+
+  class CKernel
+
+    def load_ref_inputs(path = "", suffix = ".in" )
+      return load_ref_files( path, suffix, :in )
+    end
+
+    def load_ref_outputs(path = "", suffix = ".out" )
+      return load_ref_files( path, suffix, :out )
+    end
+
+    def compare_ref(ref_outputs, outputs, epsilon = nil)
+      res = {}
+      @procedure.parameters.each_with_index { |param, indx|
+        if param.direction == :in or param.constant then
+          next
+        end
+        if param.dimension then
+          diff = (outputs[indx] - ref_outputs[indx]).abs
+          if epsilon then
+            diff.each { |elem|
+              raise "Error: #{param.name} different from ref by: #{elem}!" if elem > epsilon
+            }
+          end
+          res[param.name] = diff.max
+        else
+          raise "Error: #{param.name} different from ref: #{outputs[indx]} != #{ref_outputs[indx]} !" if epsilon and (outputs[indx] - ref_outputs[indx]).abs > epsilon
+          res[param.name] = (outputs[indx] - ref_outputs[indx]).abs
+        end
+      }
+      return res
+    end
+
+    def get_array_type(param)
+      if param.type.class == Real then
+        case param.type.size
+        when 4
+          type = NArray::SFLOAT
+        when 8
+          type = NArray::FLOAT
+        else
+          STDERR::puts "Unsupported Float size for NArray: #{param.type.size}, defaulting to byte" if debug?
+          type = NArray::BYTE
+        end
+      elsif param.type.class == Int then
+        case param.type.size
+        when 1
+          type = NArray::BYTE
+        when 2
+          type = NArray::SINT
+        when 4
+          type = NArray::SINT
+        else
+          STDERR::puts "Unsupported Int size for NArray: #{param.type.size}, defaulting to byte" if debug?
+          type = NArray::BYTE
+        end
+      else
+        STDERR::puts "Unkown array type for NArray: #{param.type}, defaulting to byte" if debug?
+        type = NArray::BYTE
+      end
+      return type
+    end
+
+    def get_scalar_type(param)
+      if param.type.class == Real then
+        case param.type.size
+        when 4
+          type = "f"
+        when 8
+          type = "d"
+        else
+          raise "Unsupported Real scalar size: #{param.type.size}!"
+        end
+      elsif param.type.class == Int then
+        case param.type.size
+        when 1
+          type = "C"
+        when 2
+          type = "S"
+        when 4
+          type = "L"
+        when 8
+          type = "Q"
+        else
+          raise "Unsupported Int scalar size: #{param.type.size}!"
+        end
+        if param.type.signed? then
+          type.downcase!
+        end
+      end
+      return type
+    end
+
+    def read_param(param, directory, suffix, intent)
+      if intent == :out and ( param.direction == :in or param.constant ) then
+        return nil
+      end
+      f = File::new( directory + "/" + param.name+suffix, "rb" )
+      if param.dimension then
+        type = get_array_type(param)
+        if f.size == 0 then
+          res = NArray::new(type, 1)
+        else
+          res = NArray.to_na(f.read, type)
+        end
+      else
+        type = get_scalar_type(param)
+        res = f.read.unpack(type).first
+      end
+      f.close
+      return res
+    end
+
+    def get_gpu_dim(directory)
+      f = File::new( directory + "/problem_size", "r")
+      s = f.read
+      local_dim, global_dim = s.scan(/<(.*?)>/)
+      local_dim  = local_dim.pop.split(",").collect!{ |e| e.to_i }
+      global_dim = global_dim.pop.split(",").collect!{ |e| e.to_i }
+      (local_dim.length..2).each{ |i| local_dim[i] = 1 }
+      (global_dim.length..2).each{ |i| global_dim[i] = 1 }
+      if @lang == CL then
+        local_dim.each_index { |indx| global_dim[indx] *= local_dim[indx] }
+        res = { :global_work_size => global_dim, :local_work_size => local_dim }
+      else
+        res = { :block_number => global_dim, :block_size => local_dim }
+      end
+      f.close
+      return res
+    end
+
+    def load_ref_files(  path = "", suffix = "", intent )
+      proc_path = path + "/#{@procedure.name}/"
+      res_h = {}
+      begin
+        dirs = Pathname.new(proc_path).children.select { |c| c.directory? }
+      rescue
+        return res_h
+      end
+      dirs.collect! { |d| d.to_s }
+      dirs.each { |d|
+        res = [] 
+        @procedure.parameters.collect { |param|
+          res.push read_param(param, d, suffix, intent)
+        }
+        if @lang == CUDA or @lang == CL then
+          res.push get_gpu_dim(d)
+        end
+        res_h[d] =  res
+      }
+      return res_h
+    end
+
+  end
+
+end

data/lib/BOAST/Runtime/OpenCLRuntime.rb

@@ -0,0 +1,181 @@
+module BOAST
+  module OpenCLRuntime
+
+   def select_cl_platform(options)
+      platforms = OpenCL::get_platforms
+      if options[:platform_vendor] then
+        platforms.select!{ |p|
+          p.vendor.match(options[:platform_vendor])
+        }
+      elsif options[:CLVENDOR] then
+        platforms.select!{ |p|
+          p.vendor.match(options[:CLVENDOR])
+        }
+      end
+      if options[:CLPLATFORM] then
+        platforms.select!{ |p|
+          p.name.match(options[:CLPLATFORM])
+        }
+      end
+      return platforms.first
+    end
+
+    def select_cl_device(options)
+      platform = select_cl_platform(options)
+      type = options[:device_type] ? OpenCL::Device::Type.const_get(options[:device_type]) : options[:CLDEVICETYPE] ? OpenCL::Device::Type.const_get(options[:CLDEVICETYPE]) : OpenCL::Device::Type::ALL
+      devices = platform.devices(type)
+      if options[:device_name] then
+        devices.select!{ |d|
+          d.name.match(options[:device_name])
+        }
+      elsif options[:CLDEVICE] then
+        devices.select!{ |d|
+          d.name.match(options[:CLDEVICE])
+        }
+      end
+      return devices.first
+    end
+
+    def init_opencl_types
+      @@opencl_real_types = {
+        2 => OpenCL::Half,
+        4 => OpenCL::Float,
+        8 => OpenCL::Double
+      }
+
+      @@opencl_int_types = {
+        true => {
+          1 => OpenCL::Char,
+          2 => OpenCL::Short,
+          4 => OpenCL::Int,
+          8 => OpenCL::Long
+        },
+        false => {
+          1 => OpenCL::UChar,
+          2 => OpenCL::UShort,
+          4 => OpenCL::UInt,
+          8 => OpenCL::ULong
+        }
+      }
+    end
+
+    def init_opencl(options)
+      require 'opencl_ruby_ffi'
+      init_opencl_types
+      device = select_cl_device(options)
+      @context = OpenCL::create_context([device])
+      program = @context.create_program_with_source([@code.string])
+      opts = options[:CLFLAGS]
+      begin
+        program.build(:options => options[:CLFLAGS])
+      rescue OpenCL::Error => e
+        puts e.to_s
+        puts program.build_status
+        puts program.build_log
+        if options[:verbose] or get_verbose then
+          puts @code.string
+        end
+        raise "OpenCL Failed to build #{@procedure.name}"
+      end
+      if options[:verbose] or get_verbose then
+        program.build_log.each {|dev,log|
+          puts "#{device.name}: #{log}"
+        }
+      end
+      @queue = @context.create_command_queue(device, :properties => OpenCL::CommandQueue::PROFILING_ENABLE)
+      @kernel = program.create_kernel(@procedure.name)
+      return self
+    end
+
+    def create_opencl_array(arg, parameter)
+      if parameter.direction == :in then
+        flags = OpenCL::Mem::Flags::READ_ONLY
+      elsif parameter.direction == :out then
+        flags = OpenCL::Mem::Flags::WRITE_ONLY
+      else
+        flags = OpenCL::Mem::Flags::READ_WRITE
+      end
+      if parameter.texture then
+        param = @context.create_image_2D( OpenCL::ImageFormat::new( OpenCL::ChannelOrder::R, OpenCL::ChannelType::UNORM_INT8 ), arg.size * arg.element_size, 1, :flags => flags )
+        @queue.enqueue_write_image( param, arg, :blocking => true )
+      else
+        param = @context.create_buffer( arg.size * arg.element_size, :flags => flags )
+        @queue.enqueue_write_buffer( param, arg, :blocking => true )
+      end
+      return param
+    end
+
+    def create_opencl_scalar(arg, parameter)
+      if parameter.type.is_a?(Real) then
+        return @@opencl_real_types[parameter.type.size]::new(arg)
+      elsif parameter.type.is_a?(Int) then
+        return @@opencl_int_types[parameter.type.signed][parameter.type.size]::new(arg)
+      else
+        return arg
+      end
+    end
+
+    def create_opencl_param(arg, parameter)
+      if parameter.dimension then
+        return create_opencl_array(arg, parameter)
+      else
+        return create_opencl_scalar(arg, parameter)
+      end
+    end
+
+    def read_opencl_param(param, arg, parameter)
+      if parameter.texture then
+        @queue.enqueue_read_image( param, arg, :blocking => true )
+      else
+        @queue.enqueue_read_buffer( param, arg, :blocking => true )
+      end
+    end
+
+    def build(options={})
+      compiler_options = BOAST::get_compiler_options
+      compiler_options.update(options)
+      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}
+  params = []
+  opts = {}
+  opts = args.pop if args.length == #{@procedure.parameters.length+1}
+  @procedure.parameters.each_index { |i|
+    params[i] = create_opencl_param( args[i], @procedure.parameters[i] )
+  }
+  params.each_index{ |i|
+    @kernel.set_arg(i, params[i])
+  }
+  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] )
+    end
+  }
+  result = {}
+  result[:start] = event.profiling_command_start
+  result[:end] = event.profiling_command_end
+  result[:duration] = (result[:end] - result[:start])/1000000000.0
+  return result
+end
+EOF
+      eval run_method
+      return self
+    end
+
+  end
+
+end

data/lib/BOAST/Runtime/Probe.rb

@@ -0,0 +1,136 @@
+module BOAST
+
+  module TimerProbe
+    extend PrivateStateAccessor
+
+    RESULT = BOAST::Int( "_boast_duration", :size => 8 )
+
+    module_function
+
+    def header
+      if OS.mac? then
+        get_output.print <<EOF
+#if __cplusplus
+extern "C" {
+#endif
+#include <mach/mach_time.h>
+#if __cplusplus
+}
+#endif
+EOF
+      else
+        get_output.print "#include <time.h>\n"
+      end
+    end
+
+    def decl
+      if OS.mac? then
+        get_output.print "  uint64_t _mac_boast_start, _mac_boast_stop;\n"
+        get_output.print "  mach_timebase_info_data_t _mac_boast_timebase_info;\n"
+      else
+        get_output.print "  struct timespec _boast_start, _boast_stop;\n"
+      end
+      BOAST::decl RESULT
+    end
+
+    def configure
+    end
+
+    def start
+      if OS.mac? then
+        get_output.print "  _mac_boast_start = mach_absolute_time();\n"
+      else
+        get_output.print "  clock_gettime(CLOCK_REALTIME, &_boast_start);\n"
+      end
+    end
+
+    def stop
+      if OS.mac? then
+        get_output.print "  _mac_boast_stop = mach_absolute_time();\n"
+      else
+        get_output.print "  clock_gettime(CLOCK_REALTIME, &_boast_stop);\n"
+      end
+    end
+
+    def compute
+      if @lang != CUDA then
+        if OS.mac? then
+          get_output.print "  mach_timebase_info(&_mac_boast_timebase_info);\n"
+          get_output.print "  #{RESULT} = (_mac_boast_stop - _mac_boast_start) * _mac_boast_timebase_info.numer / _mac_boast_timebase_info.denom;\n"
+        else
+          get_output.print "  #{RESULT} = (_boast_stop.tv_sec - _boast_start.tv_sec) * (unsigned long long int)1000000000 + _boast_stop.tv_nsec - _boast_start.tv_nsec;\n"
+        end
+          get_output.print "  rb_hash_aset(_boast_stats,ID2SYM(rb_intern(\"duration\")),rb_float_new((double)#{RESULT}*(double)1e-9));\n"
+      end
+    end
+
+  end
+
+  module PAPIProbe
+    extend PrivateStateAccessor
+
+    module_function
+
+    def name
+      return "PAPI"
+    end
+
+    def header
+    end
+
+    def decl
+      get_output.print "  VALUE _boast_event_set = Qnil;\n"
+      get_output.print "  VALUE _boast_papi_results = Qnil;\n"
+    end
+
+    def configure
+      get_output.print <<EOF
+  if( _boast_rb_opts != Qnil ) {
+     VALUE _boast_PAPI_rb_ptr = Qnil;
+    _boast_PAPI_rb_ptr = rb_hash_aref(_boast_rb_opts, ID2SYM(rb_intern("PAPI")));
+    if( _boast_PAPI_rb_ptr != Qnil ) {
+      VALUE _boast_PAPI = Qnil;
+      VALUE _boast_EventSet = Qnil;
+      rb_eval_string("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_PAPI_rb_ptr);
+    }
+  }
+EOF
+    end
+
+    def start
+      get_output.print <<EOF
+  if( _boast_event_set != Qnil) {
+    rb_funcall(_boast_event_set, rb_intern("start"), 0);
+  }
+EOF
+  end
+
+    def stop
+      get_output.print <<EOF
+  if( _boast_event_set != Qnil) {
+    _boast_papi_results = rb_funcall(_boast_event_set, rb_intern("stop"), 0);
+  }
+EOF
+    end
+
+    def compute
+      get_output.print <<EOF
+  if( _boast_papi_results != Qnil) {
+    VALUE _boast_papi_stats = Qnil;
+    _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_results = 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_results);
+  }
+EOF
+    end
+
+  end
+
+end
+

data/lib/BOAST.rb

@@ -1,26 +1,37 @@
-require 'BOAST/State.rb'
-require 'BOAST/Functors.rb'
-require 'BOAST/Inspectable.rb'
-require 'BOAST/Transitions.rb'
-require 'BOAST/Arithmetic.rb'
-require 'BOAST/Operators.rb'
-require 'BOAST/DataTypes.rb'
-require 'BOAST/Expression.rb'
-require 'BOAST/Index.rb'
-require 'BOAST/Variable.rb'
-require 'BOAST/Slice.rb'
-require 'BOAST/FuncCall.rb'
-require 'BOAST/Procedure.rb'
-require 'BOAST/Algorithm.rb'
-require 'BOAST/ControlStructure.rb'
-require 'BOAST/OpenMP.rb'
-require 'BOAST/If.rb'
-require 'BOAST/For.rb'
-require 'BOAST/Case.rb'
-require 'BOAST/While.rb'
-require 'BOAST/Pragma.rb'
-require 'BOAST/CKernel.rb'
-require 'BOAST/Parens.rb'
-require 'BOAST/BOAST_OpenCL.rb'
-require 'BOAST/Optimization.rb'
-require 'BOAST/Print.rb'
+require 'BOAST/Language/State.rb'
+require 'BOAST/Language/Functors.rb'
+require 'BOAST/Language/Inspectable.rb'
+require 'BOAST/Language/Transitions.rb'
+require 'BOAST/Language/Arithmetic.rb'
+require 'BOAST/Language/Operators.rb'
+require 'BOAST/Language/DataTypes.rb'
+require 'BOAST/Language/Expression.rb'
+require 'BOAST/Language/Index.rb'
+require 'BOAST/Language/Variable.rb'
+require 'BOAST/Language/Slice.rb'
+require 'BOAST/Language/FuncCall.rb'
+require 'BOAST/Language/Procedure.rb'
+require 'BOAST/Language/Algorithm.rb'
+require 'BOAST/Language/ControlStructure.rb'
+require 'BOAST/Language/OpenMP.rb'
+require 'BOAST/Language/If.rb'
+require 'BOAST/Language/For.rb'
+require 'BOAST/Language/Case.rb'
+require 'BOAST/Language/While.rb'
+require 'BOAST/Language/Pragma.rb'
+require 'BOAST/Runtime/Config.rb'
+require 'BOAST/Runtime/Probe.rb'
+require 'BOAST/Runtime/Compilers.rb'
+require 'BOAST/Runtime/OpenCLRuntime.rb'
+require 'BOAST/Runtime/CompiledRuntime.rb'
+require 'BOAST/Runtime/CRuntime.rb'
+require 'BOAST/Runtime/CUDARuntime.rb'
+require 'BOAST/Runtime/FORTRANRuntime.rb'
+require 'BOAST/Runtime/FFIRuntime.rb'
+require 'BOAST/Runtime/MPPARuntime.rb'
+require 'BOAST/Runtime/CKernel.rb'
+require 'BOAST/Runtime/NonRegression.rb'
+require 'BOAST/Language/Parens.rb'
+require 'BOAST/Language/BOAST_OpenCL.rb'
+require 'BOAST/Language/Optimization.rb'
+require 'BOAST/Language/Print.rb'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: BOAST
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Brice Videau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-04 00:00:00.000000000 Z
+date: 2015-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: narray
@@ -153,33 +153,45 @@ extra_rdoc_files: []
 files:
 - BOAST.gemspec
 - LICENSE
+- README.md
 - lib/BOAST.rb
-- lib/BOAST/Algorithm.rb
-- lib/BOAST/Arithmetic.rb
-- lib/BOAST/BOAST_OpenCL.rb
-- lib/BOAST/CKernel.rb
-- lib/BOAST/Case.rb
-- lib/BOAST/ControlStructure.rb
-- lib/BOAST/DataTypes.rb
-- lib/BOAST/Expression.rb
-- lib/BOAST/For.rb
-- lib/BOAST/FuncCall.rb
-- lib/BOAST/Functors.rb
-- lib/BOAST/If.rb
-- lib/BOAST/Index.rb
-- lib/BOAST/Inspectable.rb
-- lib/BOAST/OpenMP.rb
-- lib/BOAST/Operators.rb
-- lib/BOAST/Optimization.rb
-- lib/BOAST/Parens.rb
-- lib/BOAST/Pragma.rb
-- lib/BOAST/Print.rb
-- lib/BOAST/Procedure.rb
-- lib/BOAST/Slice.rb
-- lib/BOAST/State.rb
-- lib/BOAST/Transitions.rb
-- lib/BOAST/Variable.rb
-- lib/BOAST/While.rb
+- lib/BOAST/Language/Algorithm.rb
+- lib/BOAST/Language/Arithmetic.rb
+- lib/BOAST/Language/BOAST_OpenCL.rb
+- lib/BOAST/Language/Case.rb
+- lib/BOAST/Language/ControlStructure.rb
+- lib/BOAST/Language/DataTypes.rb
+- lib/BOAST/Language/Expression.rb
+- lib/BOAST/Language/For.rb
+- lib/BOAST/Language/FuncCall.rb
+- lib/BOAST/Language/Functors.rb
+- lib/BOAST/Language/If.rb
+- lib/BOAST/Language/Index.rb
+- lib/BOAST/Language/Inspectable.rb
+- lib/BOAST/Language/OpenMP.rb
+- lib/BOAST/Language/Operators.rb
+- lib/BOAST/Language/Optimization.rb
+- lib/BOAST/Language/Parens.rb
+- lib/BOAST/Language/Pragma.rb
+- lib/BOAST/Language/Print.rb
+- lib/BOAST/Language/Procedure.rb
+- lib/BOAST/Language/Slice.rb
+- lib/BOAST/Language/State.rb
+- lib/BOAST/Language/Transitions.rb
+- lib/BOAST/Language/Variable.rb
+- lib/BOAST/Language/While.rb
+- lib/BOAST/Runtime/CKernel.rb
+- lib/BOAST/Runtime/CRuntime.rb
+- lib/BOAST/Runtime/CUDARuntime.rb
+- lib/BOAST/Runtime/CompiledRuntime.rb
+- lib/BOAST/Runtime/Compilers.rb
+- lib/BOAST/Runtime/Config.rb
+- lib/BOAST/Runtime/FFIRuntime.rb
+- lib/BOAST/Runtime/FORTRANRuntime.rb
+- lib/BOAST/Runtime/MPPARuntime.rb
+- lib/BOAST/Runtime/NonRegression.rb
+- lib/BOAST/Runtime/OpenCLRuntime.rb
+- lib/BOAST/Runtime/Probe.rb
 homepage: https://github.com/Nanosim-LIG/boast
 licenses:
 - BSD