BOAST 1.3.5 → 2.0.0

data/lib/BOAST/Language/While.rb

@@ -7,7 +7,11 @@ module BOAST
 
     attr_reader :condition
 
+    # Creates a new instance of the While construct.
+    # @param [Expression] condition
+    # @param [Proc,nil] block if given, will be evaluated when {pr} is called
     def initialize(condition, &block)
+      super()
       @condition = condition
       @block = block
     end
@@ -30,10 +34,13 @@ module BOAST
     eval token_string_generator( * %w{while cond} )
     eval token_string_generator( * %w{end} )
 
+    # Returns a string representation of the While construct.
     def to_s
       return while_string(@condition)
     end
 
+    # Opens the While construct (keyword, condition, opening bracket in C like languages). The result is printed to the BOAST output.
+    # @return [self]
     def open
       s=""
       s += indent
@@ -43,16 +50,24 @@ module BOAST
       return self
     end
 
-    def pr(*args)
+    # Prints the While construct to the BOAST output (see {open}).
+    # If a block is provided during initialization, it will be printed and the construct will be closed (see {close}).
+    # @param [Array<Object>] args any number of arguments to pass to the block
+    # @param [Proc] block an optional block to be evaluated. Supersede the one given at initialization
+    # @return [self]
+    def pr(*args, &block)
       args = @args if args.length == 0 and @args
+      block = @block unless block
       open
-      if @block then
-        @block.call(*args)
+      if block then
+        block.call(*args)
         close
       end
       return self
     end
 
+    # Closes the While construct (keyword, closing bracket in C like languages). The result is printed to the BOAST output.
+    # @return [self]
     def close
       decrement_indent_level      
       s = ""

data/lib/BOAST/Optimization/Optimization.rb

@@ -25,6 +25,8 @@ module BOAST
     HASH_NAME = "options"
 
     def initialize( *parameters )
+      @rules = nil
+      @checkers = nil
       if parameters.length == 1 and parameters[0].is_a?(Hash) then
         @parameters = []
         parameters[0].each { |key, value|

data/lib/BOAST/Runtime/AffinityProbe.rb

@@ -6,10 +6,11 @@ module BOAST
 
     module_function
 
+    def cflags
+      return "-D_GNU_SOURCE"
+    end
+
     def header
-      get_output.puts "#ifndef _GNU_SOURCE"
-      get_output.puts "#define _GNU_SOURCE"
-      get_output.puts "#endif"
       get_output.puts "#include <sched.h>"
     end
 
@@ -60,6 +61,9 @@ EOF
 EOF
     end
 
+    def store
+    end
+
   end
 
 end

data/lib/BOAST/Runtime/CKernel.rb

@@ -23,6 +23,7 @@ module BOAST
     attr_accessor :architecture
     attr_accessor :kernels
     attr_accessor :cost_function
+    attr_accessor :includes
 
     # Creates a new CKernel object. BOAST output is redirected to the CKernel. If the chain_code state is set the current BOAST output, as returned by {BOAST.get_output}, is used.
     # @param [Hash] options contains named options
@@ -55,6 +56,8 @@ module BOAST
       else
         @architecture = get_architecture
       end
+      @includes = []
+      @includes = [options[:includes]].flatten if options[:includes]
 
       case @lang
       when CL

data/lib/BOAST/Runtime/CRuntime.rb

@@ -9,6 +9,10 @@ module BOAST
     def fill_library_header
       get_output.puts "#include <stdlib.h>"
       get_output.puts "#include <inttypes.h>"
+      get_output.puts "#include <math.h>"
+      @includes.each { |inc|
+        get_output.puts "#include \"#{inc}\""
+      }
       get_output.puts "#define __assume_aligned(lvalueptr, align) lvalueptr = __builtin_assume_aligned (lvalueptr, align)" if @compiler_options[:CC].match("gcc")
     end
 

data/lib/BOAST/Runtime/CompiledRuntime.rb

@@ -8,7 +8,12 @@ require 'os'
 
 class Dir
   module Tmpname
-    module_function
+    class << self
+      undef_method :make_tmpname
+    end
+
+    undef_method :make_tmpname
+
     def make_tmpname(prefix_suffix, n)
       case prefix_suffix
       when String
@@ -25,6 +30,9 @@ class Dir
       path << "_#{n}" if n
       path << suffix
     end
+
+    module_function :make_tmpname
+
   end
 end
 
@@ -86,6 +94,10 @@ module BOAST
       return "#{base_path}.#{RbConfig::CONFIG["OBJEXT"]}"
     end
 
+    def library_nofpic_object
+      return "#{base_path}.nofpic#{RbConfig::CONFIG["OBJEXT"]}"
+    end
+
     def library_path
       return "#{base_path}.#{RbConfig::CONFIG["DLEXT"]}"
     end
@@ -94,10 +106,26 @@ module BOAST
       return module_file_path
     end
 
+    def executable_source
+      return "#{base_path}_executable.c"
+    end
+
+    def executable_object
+      return "#{base_path}_executable.nofpic#{RbConfig::CONFIG["OBJEXT"]}"
+    end
+
+    def target_executable
+      return "#{base_path}_executable"
+    end
+
     def target_depends
       return [ module_file_object, library_object ]
     end
 
+    def target_executable_depends
+      return [ library_nofpic_object, executable_object ]
+    end
+
     def save_binary
       f = File::open(library_object,"rb")
       @binary = StringIO::new
@@ -112,14 +140,35 @@ module BOAST
       f.close
     end
 
-    def create_targets( linker, ldshared, ldflags, kernel_files)
+    def save_module
+      f = File::open(module_file_path, "rb")
+      @module_binary = StringIO::new
+      @module_binary.write( f.read )
+      f.close
+    end
+
+    def save_executable
+      f = File::open(target_executable, "rb")
+      @executable = StringIO::new
+      @executable.write( f.read )
+      f.close
+    end
+
+    def create_targets( linker, ldshared, ldshared_flags, ldflags, kernel_files)
       file target => target_depends do
-        #puts "#{linker} #{ldshared} -o #{target} #{target_depends.join(" ")} #{(kernel_files.collect {|f| f.path}).join(" ")} #{ldflags}"
-        sh "#{linker} #{ldshared} -o #{target} #{target_depends.join(" ")} #{(kernel_files.collect {|f| f.path}).join(" ")} #{ldflags}"
+        #puts "#{linker} #{ldshared} -o #{target} #{target_depends.join(" ")} #{(kernel_files.collect {|f| f.path}).join(" ")} #{ldshared_flags} #{ldflags}"
+        sh "#{linker} #{ldshared} -o #{target} #{target_depends.join(" ")} #{(kernel_files.collect {|f| f.path}).join(" ")} #{ldshared_flags} #{ldflags}"
       end
       Rake::Task[target].invoke
     end
 
+    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}"
+      end
+      Rake::Task[target_executable].invoke
+    end
+
     def method_name
       return @procedure.name
     end
@@ -138,19 +187,14 @@ module BOAST
 
     def create_library_source
       f = File::open(library_source,"w+")
-      previous_lang = get_lang
-      previous_output = get_output
-      set_output(f)
-      set_lang(@lang)
-
-      fill_library_source
+      push_env( :output => f, :lang => @lang ) {
+        fill_library_source
 
-      if debug_source? then
-        f.rewind
-        puts f.read
-      end
-      set_output(previous_output)
-      set_lang(previous_lang)
+        if debug_source? or debug_kernel_source? then
+          f.rewind
+          puts f.read
+        end
+      }
       f.close
     end
 
@@ -162,6 +206,9 @@ module BOAST
 #include "narray.h"
 #endif
 EOF
+      @includes.each { |inc|
+        get_output.puts "#include \"#{inc}\""
+      }
     end
 
     def fill_module_preamble
@@ -215,26 +262,26 @@ EOF
     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
+      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]
+        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|
+          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);"
+        end
       }
-      get_output.puts "  #{@procedure.properties[:return].type.decl} _boast_ret;" if @procedure.properties[:return]
-      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|
-        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);"
-      end
-      pop_env(:decl_module)
     end
 
     def copy_scalar_param_from_ruby( param, ruby_param )
@@ -252,11 +299,23 @@ EOF
       (rb_ptr === ruby_param).pr
       get_output.print <<EOF
   if (TYPE(_boast_rb_ptr) == T_STRING) {
-    #{param} = (void *) RSTRING_PTR(_boast_rb_ptr);
+    #{
+  if param.dimension then
+    "#{param} = (void *)RSTRING_PTR(_boast_rb_ptr)"
+  else
+    (param === param.copy("*(void *)RSTRING_PTR(_boast_rb_ptr)", :dimension => Dim(), :vector_length => 1)).to_s
+  end
+    };
   } else if ( IsNArray(_boast_rb_ptr) ) {
     struct NARRAY *_boast_n_ary;
     Data_Get_Struct(_boast_rb_ptr, struct NARRAY, _boast_n_ary);
-    #{param} = (void *) _boast_n_ary->ptr;
+    #{
+  if param.dimension then
+    "#{param} = (void *) _boast_n_ary->ptr"
+  else
+    (param === 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}");
   }
@@ -266,17 +325,16 @@ EOF
     def get_params_value
       argc = @procedure.parameters.length
       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")
-      push_env(:decl_module => true)
-      @procedure.parameters.each_index do |i|
-        param = @procedure.parameters[i]
-        if not param.dimension then
-          copy_scalar_param_from_ruby(param, argv[i])
-        else
-          copy_array_param_from_ruby(param, argv[i])
+      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])
+          else
+            copy_array_param_from_ruby(param, argv[i])
+          end
         end
-      end
-      pop_env(:decl_module)
+      }
     end
 
     def create_procedure_call
@@ -301,23 +359,67 @@ EOF
       end
     end
 
+    def copy_scalar_param_to_file(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);
+  fclose(__boast_f);
+EOF
+      end
+    end
+
+    def copy_scalar_param_from_file(param, base_path)
+      get_output.puts <<EOF
+  __boast_f = fopen("#{base_path}/#{param}.in", "rb");
+  fread(&#{param}, sizeof(#{param}), 1, __boast_f);
+  fclose(__boast_f);
+EOF
+    end
+
     def copy_array_param_to_ruby(param, ruby_param)
     end
 
+    def copy_array_param_to_file(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);
+  fclose(__boast_f);
+  free(#{param});
+EOF
+      else
+        get_output.puts <<EOF
+  free(#{param});
+EOF
+      end
+    end
+
+    def copy_array_param_from_file(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);
+  fclose(__boast_f);
+EOF
+    end
+
     def get_results
       argc = @procedure.parameters.length
       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")
-      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])
-        else
-          copy_array_param_to_ruby(param, argv[i])
+      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])
+          else
+            copy_array_param_to_ruby(param, argv[i])
+          end
         end
-      end
-      pop_env(:decl_module)
+      }
     end
 
     def store_results
@@ -329,6 +431,118 @@ EOF
       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)
+          else
+            copy_array_param_from_file(param, base_path)
+          end
+        end
+      }
+    end
+
+    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)
+          else
+            copy_array_param_to_file(param, base_path)
+          end
+        end
+      }
+    end
+
+    def fill_executable_source
+      get_output.puts "#include <inttypes.h>"
+      get_output.puts "#include <stdlib.h>"
+      get_output.puts "#include <stdio.h>"
+      @includes.each { |inc|
+        get_output.puts "#include \"#{inc}\""
+      }
+      @probes.map(&:header)
+      @procedure.boast_header(@lang)
+
+      get_output.print <<EOF
+void Init_#{base_name}( void );
+int _boast_repeat;
+void Init_#{base_name}( void ) {
+EOF
+      increment_indent_level
+      output.puts "  FILE * __boast_f;"
+      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.map(&:configure)
+
+      get_executable_params_value( "#{@tmp_dir}/#{@procedure.name}/#{base_name}" )
+
+      @probes.reverse.map(&:start)
+
+      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 "#{method_name}( "
+      get_output.print create_procedure_call_parameters.join(", ")
+      get_output.puts  " );"
+      get_output.puts  "  }"
+
+      @probes.map(&:stop)
+
+      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)
+
+      end
+
+      get_executable_params_return_value( "#{@tmp_dir}/#{@procedure.name}/#{base_name}" )
+
+      @probes.map(&:compute)
+
+      @probes.map(&:to_yaml)
+
+      decrement_indent_level
+      get_output.print <<EOF
+}
+int main(int argc, char * argv[]) {
+  _boast_repeat=atoi(argv[1]);
+  Init_#{base_name}();
+  return 0;
+}
+EOF
+
+    end
+
+    def create_executable_source
+      f = File::open(executable_source, "w+")
+      push_env(:output => f, :lang => C) {
+        fill_executable_source
+
+        if debug_source? then
+          f.rewind
+          puts f.read
+        end
+      }
+      f.close
+    end
+
     def fill_module_file_source
       fill_module_header
       @probes.map(&:header)
@@ -360,7 +574,10 @@ EOF
 
       get_results
 
-      @probes.map(&:compute)
+      @probes.each { |p|
+        p.compute
+        p.store
+      }
 
       store_results
 
@@ -371,16 +588,14 @@ EOF
 
     def create_module_file_source
       f = File::open(module_file_source, "w+")
-      push_env(:lang => C)
-      push_env(:output => f)
-
-      fill_module_file_source
+      push_env(:output => f, :lang => C) {
+        fill_module_file_source
 
-      if debug_source? then
-        f.rewind
-        puts f.read
-      end
-      pop_env(:lang, :output)
+        if debug_source? then
+          f.rewind
+          puts f.read
+        end
+      }
       f.close
     end
 
@@ -397,6 +612,10 @@ EOF
       return [ module_file_source, library_source ]
     end
 
+    def target_executable_sources
+      return [ executable_source, library_source ]
+    end
+
     def cleanup(kernel_files)
       ([target] + target_depends + target_sources).each { |fn|
         File::unlink(fn)
@@ -406,35 +625,123 @@ EOF
       }
     end
 
+    def cleanup_executable(kernel_files)
+      ( [target_executable] + target_executable_depends + target_executable_sources ).each { |fn|
+        File::unlink(fn)
+      }
+      kernel_files.each { |f|
+        f.unlink
+      }
+    end
+
+    def run_executable(*params)
+      options = {:repeat => 1}
+      if params.last.kind_of?(Hash) then
+        options.update(params.last)
+        ps = params[0..-2]
+      else
+        ps = params[0..-1]
+      end
+
+      Dir::mkdir(@tmp_dir, 0700) unless Dir::exist?(@tmp_dir)
+
+      dump_executable
+      dump_ref_inputs( { base_name => ps }, @tmp_dir )
+      boast_ret = YAML::load `#{target_executable} #{options[:repeat]}`
+      File::unlink(target_executable) unless keep_temp
+
+      res = load_ref_outputs(@tmp_dir)["#{@tmp_dir}/#{@procedure.name}/#{base_name}"]
+      @procedure.parameters.each_with_index { |param, indx|
+        if param.direction == :in or param.constant then
+          next
+        end
+        if param.dimension then
+          ps[indx][0..-1] = res[indx][0..-1]
+        else
+          boast_ret[:reference_return] = {} unless boast_ret[:reference_return]
+          boast_ret[:reference_return][param.name.to_sym] = res[indx]
+        end
+      }
+      p = Pathname::new("#{@tmp_dir}/#{@procedure.name}/#{base_name}")
+      p.children.each { |f| File::unlink f }
+      unless keep_temp then
+        Dir::rmdir("#{@tmp_dir}/#{@procedure.name}/#{base_name}")
+        Dir::rmdir("#{@tmp_dir}/#{@procedure.name}")
+        Dir::rmdir("#{@tmp_dir}")
+      end
+      return boast_ret
+    end
+
+    def build_executable(options={})
+      compiler_options = BOAST::get_compiler_options
+      compiler_options.update(options)
+      @probes = [TimerProbe]
+      linker, _, _, ldflags = setup_compilers(@probes, compiler_options)
+      @compiler_options = compiler_options
+
+      @marker = Tempfile::new([@procedure.name,""])
+      Dir::mktmpdir { |dir|
+        @tmp_dir = "#{dir}"
+      }
+
+      kernel_files = get_sub_kernels
+
+      create_library_source
+
+      create_executable_source
+
+      save_source
+
+      create_executable_target(linker, ldflags, kernel_files)
+
+      save_executable
+
+      instance_eval <<EOF
+      def run(*args, &block)
+        run_executable(*args, &block)
+      end
+EOF
+
+      cleanup_executable(kernel_files) unless keep_temp
+
+      return self
+
+    end
+
     public
 
     def build(options={})
+      return build_executable(options) if executable? and (@lang == C or @lang == FORTRAN)
       compiler_options = BOAST::get_compiler_options
       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
+      if compiler_options[:probes] then
+        @probes = compiler_options[:probes]
+      elsif get_lang != CUDA then
         @probes = [TimerProbe, PAPIProbe]
         @probes.push EnergyProbe if EnergyProbe
         @probes.push AffinityProbe unless OS.mac?
       end
       @probes = [MPPAProbe] if @architecture == MPPA
+      linker, ldshared, ldshared_flags, ldflags = setup_compilers(@probes, compiler_options)
+      @compiler_options = compiler_options
 
       @marker = Tempfile::new([@procedure.name,""])
 
+      extend MAQAO if @compiler_options[:MAQAO_PASS]
+
       kernel_files = get_sub_kernels
 
       create_sources
 
       save_source
 
-      create_targets(linker, ldshared, ldflags, kernel_files)
+      create_targets(linker, ldshared, ldshared_flags, ldflags, kernel_files)
 
       save_binary
 
+      save_module
+
       load_module
 
       cleanup(kernel_files) unless keep_temp
@@ -444,20 +751,40 @@ EOF
       return self
     end
 
-    def dump_binary
-      f = File::open(library_object,"wb")
+    def dump_binary(path = nil)
+      f = path ? File::open(path,"wb") : File::open(library_object,"wb")
       @binary.rewind
       f.write( @binary.read )
       f.close
     end
 
-    def dump_source
-      f = File::open(library_source,"wb")
+    def dump_source(path = nil)
+      f = path ? File::open(path,"wb") : File::open(library_source,"wb")
       @source.rewind
       f.write( @source.read )
       f.close
     end
 
+    def dump_module(path = nil)
+      f = path ? File::open(path,"wb") : File::open(module_file_path,"wb")
+      @module_binary.rewind
+      f.write( @module_binary.read )
+      f.close
+    end
+
+    def dump_executable(path = nil)
+      f = path ? File::open(path,"wb",0700) : File::open(target_executable,"wb",0700)
+      @executable.rewind
+      f.write( @executable.read )
+      f.close
+    end
+
+    def reload_module
+      raise "Missing binary library data!" unless @module_binary
+      $LOADED_FEATURES.delete(module_file_path)
+      require module_file_path
+    end
+
   end
 
 end