BOAST 1.3.5 → 2.0.0

data/lib/BOAST/Runtime/Compilers.rb

@@ -43,10 +43,13 @@ module BOAST
       end
     end
 
-    def setup_c_compiler(options, includes, narray_path, runner)
+    def setup_c_compiler(options, includes, narray_path, runner, probes)
       c_mppa_compiler = "k1-gcc"
       c_compiler = options[:CC]
       cflags = options[:CFLAGS]
+      probes.each { |p|
+        cflags += " #{p.cflags}" if p.respond_to?(:cflags)
+      }
       cflags += " -march=#{get_model}"
       cflags += " -fPIC #{includes}"
       cflags += " -DHAVE_NARRAY_H" if narray_path
@@ -58,6 +61,13 @@ module BOAST
           cflags += " #{openmp_cflags}"
       end
 
+      cflags_no_fpic = cflags.gsub("-fPIC","")
+
+      rule ".nofpic#{objext}" => '.c' do |t|
+        c_call_string = "#{c_compiler} #{cflags_no_fpic} -c -o #{t.name} #{t.source}"
+        runner.call(t, c_call_string)
+      end
+
       rule ".#{objext}" => '.c' do |t|
         c_call_string = "#{c_compiler} #{cflags} -c -o #{t.name} #{t.source}"
         runner.call(t, c_call_string)
@@ -76,7 +86,7 @@ module BOAST
       end
     end
 
-    def setup_cxx_compiler(options, includes, runner)
+    def setup_cxx_compiler(options, includes, runner, probes)
       cxx_compiler = options[:CXX]
       cxxflags = options[:CXXFLAGS]
       cxxflags += " -fPIC #{includes}"
@@ -86,13 +96,20 @@ module BOAST
           cxxflags += " #{openmp_cxxflags}"
       end
 
+      cxxflags_no_fpic = cxxflags.gsub("-fPIC","")
+
+      rule ".nofpic#{RbConfig::CONFIG["OBJEXT"]}" => '.cpp' do |t|
+        cxx_call_string = "#{cxx_compiler} #{cxxflags_no_fpic} -c -o #{t.name} #{t.source}"
+        runner.call(t, cxx_call_string)
+      end
+
       rule ".#{RbConfig::CONFIG["OBJEXT"]}" => '.cpp' do |t|
         cxx_call_string = "#{cxx_compiler} #{cxxflags} -c -o #{t.name} #{t.source}"
         runner.call(t, cxx_call_string)
       end
     end
 
-    def setup_fortran_compiler(options, runner)
+    def setup_fortran_compiler(options, runner, probes)
       f_compiler = options[:FC]
       fcflags = options[:FCFLAGS]
       fcflags += " -march=#{get_model}"
@@ -104,13 +121,20 @@ module BOAST
           fcflags += " #{openmp_fcflags}"
       end
 
+      fcflags_no_fpic = fcflags.gsub("-fPIC","")
+
+      rule ".nofpic#{RbConfig::CONFIG["OBJEXT"]}" => '.f90' do |t|
+        f_call_string = "#{f_compiler} #{fcflags_no_fpic} -c -o #{t.name} #{t.source}"
+        runner.call(t, f_call_string)
+      end
+
       rule ".#{RbConfig::CONFIG["OBJEXT"]}" => '.f90' do |t|
         f_call_string = "#{f_compiler} #{fcflags} -c -o #{t.name} #{t.source}"
         runner.call(t, f_call_string)
       end
     end
 
-    def setup_cuda_compiler(options, runner)
+    def setup_cuda_compiler(options, runner, probes)
       cuda_compiler = options[:NVCC]
       cudaflags = options[:NVCCFLAGS]
       cudaflags += " --compiler-options '-fPIC','-D_FORCE_INLINES'"
@@ -121,7 +145,7 @@ module BOAST
       end
     end
 
-    def setup_linker_mppa(options, runner)
+    def setup_linker_mppa(options, runner, probes)
       objext = RbConfig::CONFIG["OBJEXT"]
       ldflags = options[:LDFLAGS]
       board = " -mboard=developer"
@@ -141,11 +165,13 @@ module BOAST
 
     end
 
-    def setup_linker(options)
+    def setup_linker(options, probes)
       ldflags = options[:LDFLAGS]
       ldflags += " -march=#{get_model}"
       ldflags += " -L#{RbConfig::CONFIG["libdir"]} #{RbConfig::CONFIG["LIBRUBYARG"]}"
-      ldflags += " -lrt" if not OS.mac?
+      probes.each { |p|
+        ldflags += " #{p.ldflags}" if p.respond_to?(:ldflags)
+      }
       ldflags += " -lcudart" if @lang == CUDA
       ldflags += " -L/usr/local/k1tools/lib64 -lmppaipc -lpcie -lz -lelf -lmppa_multiloader" if @architecture == MPPA
       ldflags += " -lmppamon -lmppabm -lm -lmppalock" if @architecture == MPPA
@@ -160,17 +186,17 @@ module BOAST
       end
 
       if OS.mac? then
-        ldflags = "-Wl,-undefined,dynamic_lookup -Wl,-multiply_defined,suppress #{ldflags}"
         ldshared = "-dynamic -bundle"
+        ldshared_flags = "-Wl,-undefined,dynamic_lookup -Wl,-multiply_defined,suppress"
       else
-        ldflags = "-Wl,-Bsymbolic-functions -Wl,-z,relro -rdynamic -Wl,-export-dynamic #{ldflags}"
         ldshared = "-shared"
+        ldshared_flags = "-Wl,-Bsymbolic-functions -Wl,-z,relro -rdynamic -Wl,-export-dynamic"
       end
 
-      return [linker, ldshared, ldflags]
+      return [linker, ldshared, ldshared_flags, ldflags]
     end
 
-    def setup_compilers(options = {})
+    def setup_compilers(probes, options = {})
       Rake::Task::clear
       verbose = options[:VERBOSE]
       verbose = get_verbose if not verbose
@@ -184,7 +210,7 @@ module BOAST
         if verbose then
           sh call_string
         else
-          status, stdout, stderr = systemu call_string
+          status, _, stderr = systemu call_string
           if not status.success? then
             puts stderr
             fail "#{t.source}: compilation failed"
@@ -193,14 +219,14 @@ module BOAST
         end
       }
 
-      setup_c_compiler(options, includes, narray_path, runner)
-      setup_cxx_compiler(options, includes, runner)
-      setup_fortran_compiler(options, runner)
-      setup_cuda_compiler(options, runner)
+      setup_c_compiler(options, includes, narray_path, runner, probes)
+      setup_cxx_compiler(options, includes, runner, probes)
+      setup_fortran_compiler(options, runner, probes)
+      setup_cuda_compiler(options, runner, probes)
       
-      setup_linker_mppa(options, runner) if @architecture == MPPA
+      setup_linker_mppa(options, runner, probes) if @architecture == MPPA
 
-      return setup_linker(options)
+      return setup_linker(options, probes)
 
     end
 

data/lib/BOAST/Runtime/Config.rb

@@ -19,6 +19,9 @@ module BOAST
     :CLDEVICETYPE => nil,
     :MAQAO => 'maqao',
     :MAQAO_FLAGS => '',
+    :MAQAO_PATH => '',
+    :MAQAO_PASS => false,
+    :MAQAO_SCRIPT => '',
     :OPENMP => false,
     :probes => nil
   }
@@ -42,19 +45,25 @@ module BOAST
   module PrivateStateAccessor
     private_boolean_state_accessor :verbose
     private_boolean_state_accessor :debug_source
+    private_boolean_state_accessor :debug_kernel_source
     private_boolean_state_accessor :ffi
+    private_boolean_state_accessor :executable
     private_boolean_state_accessor :keep_temp
     private_state_accessor :fortran_line_length
   end
 
   boolean_state_accessor :verbose
   boolean_state_accessor :debug_source
+  boolean_state_accessor :debug_kernel_source
   boolean_state_accessor :ffi
+  boolean_state_accessor :executable
   boolean_state_accessor :keep_temp
   state_accessor         :fortran_line_length
   default_state_getter :verbose,             false
   default_state_getter :debug_source,        false
+  default_state_getter :debug_kernel_source, false
   default_state_getter :ffi,                 false
+  default_state_getter :executable,          false
   default_state_getter :keep_temp,           false
   default_state_getter :fortran_line_length, 72
 

data/lib/BOAST/Runtime/EnergyProbe.rb

@@ -111,6 +111,8 @@ EOF
 EOF
     end
     def compute
+    end
+    def store
       get_output.print <<EOF
 {
   VALUE results;
@@ -147,6 +149,8 @@ EOF
       get_output.puts "_boast_energy = redfst_get(_boast_energy);"
     end
     def compute
+    end
+    def store
       get_output.print <<EOF
 {
   VALUE results;
@@ -176,13 +180,18 @@ EOF
   rb_hash_aset(_boast_stats, ID2SYM(rb_intern("energy")), results);
 }
 EOF
-		end
+    end
     def is_available?
+      return false if OS.mac?
       path = []
       if ENV['LIBRARY_PATH'] then
         path += ENV['LIBRARY_PATH'].split(':').inject([]){|mem, x| []!=mem ? mem : Dir.glob(x+'/libredfst.so')}
       end
-      path += `ldconfig -p`.gsub("\t","").split("\n").find_all { |e| e.match(/libredfst\.so/) }.collect { |e| e.split(" => ")[1] } if path == []
+      begin
+        path += `ldconfig -p`.gsub("\t","").split("\n").find_all { |e| e.match(/libredfst\.so/) }.collect { |e| e.split(" => ")[1] } if path == []
+      rescue
+        path += `/sbin/ldconfig -p`.gsub("\t","").split("\n").find_all { |e| e.match(/libredfst\.so/) }.collect { |e| e.split(" => ")[1] } if path == []
+      end
       return path != []
     end
   end
@@ -209,6 +218,8 @@ EOF
       get_output.puts "emlStop(_boast_energy);";
     end
     def compute
+    end
+    def store
       get_output.print <<EOF
 {
   VALUE results;
@@ -221,11 +232,16 @@ EOF
 EOF
     end
     def is_available?
+      return false if OS.mac?
       path = []
       if ENV['LIBRARY_PATH'] then
         path += ENV['LIBRARY_PATH'].split(':').inject([]){|mem, x| []!=mem ? mem : Dir.glob(x+'/libeml.so')}
       end
-      path += `ldconfig -p`.gsub("\t","").split("\n").find_all { |e| e.match(/libeml\.so/) }.collect { |e| e.split(" => ")[1] } if path == []
+      begin
+        path += `ldconfig -p`.gsub("\t","").split("\n").find_all { |e| e.match(/libeml\.so/) }.collect { |e| e.split(" => ")[1] } if path == []
+      rescue
+        path += `/sbin/ldconfig -p`.gsub("\t","").split("\n").find_all { |e| e.match(/libeml\.so/) }.collect { |e| e.split(" => ")[1] } if path == []
+      end
       return path != []
     end
   end

data/lib/BOAST/Runtime/FFIRuntime.rb

@@ -3,6 +3,22 @@ module BOAST
   # @private
   module FFIRuntime
 
+    def build( options = {} )
+      if options[:library_path] then
+        eval <<EOF
+    def library_path
+      return "#{options[:library_path]}"
+    end
+EOF
+        @marker = Tempfile::new([@procedure.name,""])
+        create_ffi_module
+        eval "self.extend(#{module_name})"
+        return self
+      else
+        super
+      end
+    end
+
     private
 
     def target
@@ -25,6 +41,13 @@ module BOAST
       create_library_source
     end
 
+    def save_module
+      f = File::open(library_path, "rb")
+      @module_binary = StringIO::new
+      @module_binary.write( f.read )
+      f.close
+    end
+
     def create_ffi_module
       s =<<EOF
       require 'ffi'

data/lib/BOAST/Runtime/FORTRANRuntime.rb

@@ -7,7 +7,7 @@ module BOAST
     private
 
     def method_name
-      return @procedure.name + "_"
+      return  "#{@procedure.name}_"
     end
 
     def line_limited_source

data/lib/BOAST/Runtime/MAQAO.rb

@@ -32,4 +32,33 @@ module BOAST
     end
   end
 
+  module MAQAO
+
+    def create_executable_target( linker, ldflags, kernel_files)
+      file target_executable => target_executable_depends do
+        sh "#{linker} -o #{target_executable} #{target_executable_depends.join(" ")} #{(kernel_files.collect {|f| f.path}).join(" ")} #{ldflags}"
+        maqao_script = @compiler_options[:MAQAO_SCRIPT]
+        if maqao_script == '' then
+          maqao_script = "#{@compiler_options[:MAQAO_PATH]}/scripts/maqao_from_boast.sh"
+        end
+      end
+      sh "#{maqao_script} #{@compiler_options[:MAQAO_PATH]} #{@procedure.name} Init_#{base_name} #{target_executable}"
+      Rake::Task[target_executable].invoke
+    end
+
+    def create_targets( linker, ldshared, ldflags, kernel_files)
+      file target => target_depends do
+        sh "#{linker} #{ldshared} -o #{target} #{target_depends.join(" ")} #{(kernel_files.collect {|f| f.path}).join(" ")} #{ldflags}"
+        no_fpic_obj = target_depends[1].gsub(/\.o$/, "_no_fpic.o")
+        maqao_script = @compiler_options[:MAQAO_SCRIPT]
+        if maqao_script == '' then
+          maqao_script = "#{@compiler_options[:MAQAO_PATH]}/scripts/maqao_from_boast.sh"
+        end
+        sh "#{maqao_script} #{@compiler_options[:MAQAO_PATH]} #{library_source} #{@procedure.name} Init_#{base_name} #{target} #{no_fpic_obj}"
+      end
+      Rake::Task[target].invoke
+    end
+
+  end
+
 end

data/lib/BOAST/Runtime/NonRegression.rb

@@ -10,6 +10,14 @@ module BOAST
       return load_ref_files( path, suffix, :out )
     end
 
+    def dump_ref_inputs(values, path = ".", suffix = ".in" )
+      return dump_ref_files(values, path, suffix, :in )
+    end
+
+    def dump_ref_outputs(values, path = ".", suffix = ".out" )
+      return dump_ref_files(values, path, suffix, :out )
+    end
+
     def compare_ref(ref_outputs, outputs, epsilon = nil)
       res = {}
       @procedure.parameters.each_with_index { |param, indx|
@@ -52,7 +60,7 @@ module BOAST
         when 2
           type = NArray::SINT
         when 4
-          type = NArray::SINT
+          type = NArray::INT
         else
           STDERR::puts "Unsupported Int size for NArray: #{param.type.size}, defaulting to byte" if debug?
           type = NArray::BYTE
@@ -94,12 +102,27 @@ module BOAST
       return type
     end
 
+    def write_param(param, value, directory, suffix, intent)
+      if intent == :out and ( param.direction == :in or param.constant ) then
+        return nil
+      end
+      f = File::new( directory + "/" + "#{param.name+suffix}", "wb" )
+      if param.dimension or param.vector? then
+        f.write value.to_s
+      else
+        type = get_scalar_type(param)
+        f.write [value].pack(type)
+      end
+      f.close
+      return nil
+    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
+      if param.dimension or param.vector? then
         type = get_array_type(param)
         if f.size == 0 then
           res = NArray::new(type, 1)
@@ -132,7 +155,28 @@ module BOAST
       return res
     end
 
-    def load_ref_files(  path, suffix, intent )
+    def write_gpu_dim(value, directory)
+      global_work_size = value[:global_work_size]
+      block_number = value[:block_number]
+      local_work_size = value[:local_work_size]
+      local_work_size = value[:block_size] unless local_work_size
+      (local_work_size.length..2).each{ |i| local_work_size[i] = 1 }
+      if global_work_size and not block_number then
+        block_number = []
+        (global_work_size.length..2).each{ |i| global_work_size[i] = 1 }
+        local_work_size.each_index { |i|
+          block_number[i] = global_work_size[i] / local_work_size[i]
+        }
+      end
+      (block_number.length..2).each{ |i| block_number[i] = 1 }
+
+      File::open( directory + "/problem_size", "w") { |f|
+        f.write "<#{local_work_size.join(",")}><#{block_number.join(",")}>"
+      }
+      return nil
+    end
+
+    def load_ref_files( path, suffix, intent )
       proc_path = path + "/#{@procedure.name}/"
       res_h = {}
       begin
@@ -154,6 +198,23 @@ module BOAST
       return res_h
     end
 
+    def dump_ref_files( values, path, suffix, intent )
+      proc_path = path + "/#{@procedure.name}/"
+      Dir.mkdir( proc_path ) unless File.exists?( proc_path )
+      values.each { |key, vals|
+        case_path = proc_path + "#{key}/"
+        Dir.mkdir( case_path ) unless File.exists?( case_path )
+        d = Pathname.new( case_path )
+        @procedure.parameters.each_with_index { |param, i|
+          write_param( param, vals[i], d.to_s, suffix, intent )
+        }
+        if @lang == CUDA or @lang == CL then
+          write_gpu_dim( vals.last, d.to_s )
+        end
+      }
+      return nil
+    end
+
   end
 
 end

data/lib/BOAST/Runtime/OpenCLRuntime.rb

@@ -53,7 +53,6 @@ module BOAST
         @context = OpenCL::create_context([device])
       end
       program = @context.create_program_with_source([@code.string])
-      opts = options[:CLFLAGS]
       begin
         program.build(:options => options[:CLFLAGS])
       rescue OpenCL::Error => e
@@ -130,7 +129,6 @@ module BOAST
       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}
@@ -153,17 +151,29 @@ def self.run(*args)
   if not lws then
     lws = opts[:block_size]
   end
-  event = @queue.enqueue_NDrange_kernel(@kernel, gws, :local_work_size => lws)
+  event1 = @queue.enqueue_NDrange_kernel(@kernel, gws, :local_work_size => lws)
+  if opts[:repeat] and opts[:repeat] > 1 then
+    (opts[:repeat] - 2).times {
+      @queue.enqueue_NDrange_kernel(@kernel, gws, :local_work_size => lws)
+    }
+    event2 = @queue.enqueue_NDrange_kernel(@kernel, gws, :local_work_size => lws)
+  end
   @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
   }
   @queue.finish
+  start_t = event1.profiling_command_start
+  if opts[:repeat] and opts[:repeat] > 1 then
+    end_t = event2.profiling_command_end
+  else
+    end_t = event1.profiling_command_end
+  end
   result = {}
-  result[:start] = event.profiling_command_start
-  result[:end] = event.profiling_command_end
-  result[:duration] = (result[:end] - result[:start])/1000000000.0
+  result[:start] = start_t
+  result[:end] = end_t
+  result[:duration] = (end_t - start_t)/1000000000.0
   return result
 end
 EOF