BOAST 0.9994 → 0.9995

data/BOAST.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'BOAST'
-  s.version = "0.9994"
+  s.version = "0.9995"
   s.author = "Brice Videau"
   s.email = "brice.videau@imag.fr"
   s.homepage = "https://forge.imag.fr/projects/boast/"
@@ -27,6 +27,9 @@ Gem::Specification.new do |s|
                 lib/BOAST/While.rb
                 lib/BOAST/FuncCall.rb
                 lib/BOAST/Pragma.rb
+                lib/BOAST/Inspectable.rb
+                lib/BOAST/Functors.rb
+                lib/BOAST/ControlStructure.rb
               )
   s.has_rdoc = true
   s.license = 'BSD'

data/lib/BOAST/Algorithm.rb

@@ -5,18 +5,17 @@ module BOAST
   FORTRAN = 1
   C = 2
   CL = 3
-#  OpenCL = 3
   CUDA = 4
   X86 = 1
   ARM = 2
 
-  def BOAST::get_default_lang
+  def self.get_default_lang
     lang = BOAST::const_get(ENV["BOAST_LANG"]) if ENV["BOAST_LANG"]
     return lang if lang
     return BOAST::FORTRAN
   end
 
-  def BOAST::get_default_debug
+  def self.get_default_debug
     debug = false
     debug = ENV["DEBUG"] if ENV["DEBUG"]
     return debug
@@ -35,9 +34,9 @@ module BOAST
   @@architecture = X86
   @@debug = BOAST::get_default_debug
 
-  @@env = Hash.new{|h, k| h[k] = []}
+  @@env = Hash::new{|h, k| h[k] = []}
 
-  def BOAST::push_env(vars = {})
+  def self.push_env(vars = {})
     vars.each { |key,value|
       var = nil
       begin
@@ -50,7 +49,7 @@ module BOAST
     }
   end
 
-  def BOAST::pop_env(*vars)
+  def self.pop_env(*vars)
     vars.each { |key|
       raise "Unknown module variable #{key}!" unless @@env.has_key?(key)
       ret = @@env[key].pop
@@ -59,189 +58,197 @@ module BOAST
     }
   end
 
-  def BOAST::print(a)
+  def self.print(a)
     a.print
   end
 
-  def BOAST::decl(*a)
+  def self.decl(*a)
     a.each { |d|
       d.decl
     }
   end
 
-  def BOAST::close(a)
+  def self.close(a)
     a.close
   end
 
-  def BOAST::debug=(debug)
+  def self.open(a)
+    a.open
+  end
+
+  def self.debug=(debug)
     @@debug = debug
   end
 
-  def BOAST::debug
+  def self.debug
     return @@debug
   end
 
-  def BOAST::architecture=(arch)
+  def self.architecture=(arch)
     @@architecture = arch
   end
 
-  def BOAST::set_architecture(arch)
+  def self.set_architecture(arch)
     @@architecture = arch
   end
 
-  def BOAST::architecture
+  def self.architecture
     return @@architecture
   end
 
-  def BOAST::get_architecture
+  def self.get_architecture
     return @@architecture
   end
 
-  def BOAST::indent_level=(level)
+  def self.indent_level=(level)
     @@indent_level = level
   end
 
-  def BOAST::set_indent_level(level)
+  def self.set_indent_level(level)
     @@indent_level = level
   end
 
-  def BOAST::indent_level
+  def self.indent_level
     return @@indent_level
   end
 
-  def BOAST::get_indent_level
+  def self.get_indent_level
     return @@indent_level
   end
 
-  def BOAST::indent_increment
+  def self.indent_increment
     return @@indent_increment
   end
 
-  def BOAST::get_indent_increment
+  def self.get_indent_increment
     return @@indent_increment
   end
 
-  def BOAST::increment_indent_level(increment = @@indent_increment)
+  def self.increment_indent_level(increment = @@indent_increment)
     @@indent_level += increment
   end
   
-  def BOAST::decrement_indent_level(increment = @@indent_increment)
+  def self.decrement_indent_level(increment = @@indent_increment)
     @@indent_level -= increment
   end
+
+  def self.indent
+     return " "*BOAST::get_indent_level
+  end
   
-  def BOAST::set_replace_constants(replace_constants)
+  def self.set_replace_constants(replace_constants)
     @@replace_constants = replace_constants
   end
 
-  def BOAST::replace_constants?
+  def self.replace_constants?
     return @@replace_constants
   end
 
-  def BOAST::get_replace_constants
+  def self.get_replace_constants
     return @@replace_constants
   end
 
-  def BOAST::default_int_signed=(signed)
+  def self.default_int_signed=(signed)
     @@default_int_signed = signed
   end
 
-  def BOAST::set_default_int_signed(signed)
+  def self.set_default_int_signed(signed)
     @@default_int_signed = signed
   end
 
-  def BOAST::default_int_signed?
+  def self.default_int_signed?
     return @@default_int_signed
   end
 
-  def BOAST::get_default_int_signed
+  def self.get_default_int_signed
     return @@default_int_signed
   end
 
-  def BOAST::default_int_size=(size)
+  def self.default_int_size=(size)
     @@default_int_size = size
   end
 
-  def BOAST::set_default_int_size(size)
+  def self.set_default_int_size(size)
     @@default_int_size = size
   end
 
-  def BOAST::default_int_size
+  def self.default_int_size
     return @@default_int_size
   end
 
-  def BOAST::get_default_int_size
+  def self.get_default_int_size
     return @@default_int_size
   end
 
-  def BOAST::default_real_size=(size)
+  def self.default_real_size=(size)
     @@default_real_size = size
   end
 
-  def BOAST::set_default_real_size(size)
+  def self.set_default_real_size(size)
     @@default_real_size = size
   end
 
-  def BOAST::default_real_size
+  def self.default_real_size
     return @@default_real_size
   end
 
-  def BOAST::get_default_real_size
+  def self.get_default_real_size
     return @@default_real_size
   end
 
-  def BOAST::lang=(lang)
+  def self.lang=(lang)
     @@lang = lang
   end
 
-  def BOAST::set_lang(lang)
+  def self.set_lang(lang)
     @@lang = lang
   end
 
-  def BOAST::lang
+  def self.lang
     return @@lang
   end
 
-  def BOAST::get_lang
+  def self.get_lang
     return @@lang
   end
 
-  def BOAST::output(output)
+  def self.output(output)
     @@output = output
   end
 
-  def BOAST::set_output(output)
+  def self.set_output(output)
     @@output = output
   end
 
-  def BOAST::output
+  def self.output
     return @@output
   end
 
-  def BOAST::get_output
+  def self.get_output
     return @@output
   end
 
-  def BOAST::set_chain_code(chain_code)
+  def self.set_chain_code(chain_code)
     @@chain_code = chain_code
   end
 
-  def BOAST::get_chain_code
+  def self.get_chain_code
     return @@chain_code
   end
 
-  def BOAST::array_start=(array_start)
+  def self.array_start=(array_start)
     @@array_start = array_start
   end
 
-  def BOAST::set_array_start(array_start)
+  def self.set_array_start(array_start)
     @@array_start = array_start
   end
 
-  def BOAST::array_start
+  def self.array_start
     return @@array_start
   end
 
-  def BOAST::get_array_start
+  def self.get_array_start
     return @@array_start
   end
 

data/lib/BOAST/BOAST_OpenCL.rb

@@ -6,7 +6,7 @@ module BOAST
   @@cuda_blockDim = CStruct("blockDim",:type_name => "cuda_blockDim", :members => [Int("x", :signed => false),Int("y", :signed => false),Int("z", :signed => false)])
   @@cuda_gridDim = CStruct("gridDim",:type_name => "cuda_gridDim", :members => [Int("x", :signed => false),Int("y", :signed => false),Int("z", :signed => false)])
 
-  def BOAST::barrier(*locality)
+  def self.barrier(*locality)
     if @@lang == CL then
       loc=""
       if locality.include?(:local) and locality.include?(:global) then
@@ -26,7 +26,7 @@ module BOAST
   end
 
 
-  def BOAST::get_work_dim
+  def self.get_work_dim
     if @@lang == CL then
       return FuncCall::new("get_work_dim", :returns => Int("wd", :signed => false))
     else
@@ -34,7 +34,7 @@ module BOAST
     end
   end
   
-  def BOAST::get_global_size(dim)
+  def self.get_global_size(dim)
     if @@lang == CL then
       return FuncCall::new("get_global_size", dim, :returns => Sizet)
     elsif @@lang == CUDA then
@@ -46,7 +46,7 @@ module BOAST
     end
   end
 
-  def BOAST::get_global_id(dim)
+  def self.get_global_id(dim)
     if @@lang == CL then
       return FuncCall::new("get_global_id",dim, :returns => Sizet)
     elsif @@lang == CUDA then
@@ -58,7 +58,7 @@ module BOAST
     end
   end
 
-  def BOAST::get_local_size(dim)
+  def self.get_local_size(dim)
     if @@lang == CL then
       return FuncCall::new("get_local_size",dim, :returns => Sizet)
     elsif @@lang == CUDA then
@@ -70,7 +70,7 @@ module BOAST
     end
   end
 
-  def BOAST::get_local_id(dim)
+  def self.get_local_id(dim)
     if @@lang == CL then
       return FuncCall::new("get_local_id",dim, :returns => Sizet)
     elsif @@lang == CUDA then
@@ -82,7 +82,7 @@ module BOAST
     end
   end
   
-  def BOAST::get_num_groups(dim)
+  def self.get_num_groups(dim)
     if @@lang == CL then
       return FuncCall::new("get_num_groups",dim, :returns => Sizet)
     elsif @@lang == CUDA then
@@ -94,7 +94,7 @@ module BOAST
     end
   end
 
-  def BOAST::get_group_id(dim)
+  def self.get_group_id(dim)
     if @@lang == CL then
       return FuncCall::new("get_group_id",dim, :returns => Sizet)
     elsif @@lang == CUDA then

data/lib/BOAST/CKernel.rb

@@ -36,7 +36,7 @@ module BOAST
     "icpc" => "-openmp"
   }
 
-  def BOAST::read_boast_config
+  def self.read_boast_config
     home_config_dir = ENV["XDG_CONFIG_HOME"]
     home_config_dir = "#{Dir.home}/.config" if not home_config_dir
     Dir.mkdir( home_config_dir ) if not File::exist?( home_config_dir )
@@ -72,33 +72,34 @@ module BOAST
 
   BOAST::read_boast_config
 
-  def BOAST::get_openmp_flags
+  def self.get_openmp_flags
     return @@openmp_default_flags.clone
   end
 
-  def BOAST::get_compiler_options
+  def self.get_compiler_options
     return @@compiler_default_options.clone
   end
 
-  def BOAST::verbose
+  def self.verbose
     return @@verbose
   end
 
 
-  def BOAST::get_verbose
+  def self.get_verbose
     return @@verbose
   end
 
-  def BOAST::verbose=(verbose)
+  def self.verbose=(verbose)
     @@verbose = verbose
   end
 
-  def BOAST::set_verbose(verbose)
+  def self.set_verbose(verbose)
     @@verbose = verbose
   end
 
   class CKernel
     include Rake::DSL
+    include BOAST::Inspectable
     attr_accessor :code
     attr_accessor :procedure
     attr_accessor :lang
@@ -133,11 +134,6 @@ module BOAST
       puts @code.read
     end
 
-    def to_str
-      @code.rewind
-      return code.read
-    end
-
     def to_s
       @code.rewind
       return code.read
@@ -431,7 +427,7 @@ EOF
       BOAST::set_output(module_file)
       fill_module(module_file, module_name)
       module_file.rewind
-#     puts module_file.read
+     #puts module_file.read
       module_file.close
       BOAST::set_lang(previous_lang)
       BOAST::set_output(previous_output)
@@ -474,7 +470,7 @@ EOF
       if @lang == BOAST::CUDA then
         source_file.write <<EOF
 extern "C" {
-  #{@procedure.header(BOAST::CUDA,false)}{
+  #{@procedure.boast_header_s(BOAST::CUDA)}{
     dim3 dimBlock(block_size[0], block_size[1], block_size[2]);
     dim3 dimGrid(block_number[0], block_number[1], block_number[2]);
     cudaEvent_t __start, __stop;
@@ -506,7 +502,7 @@ EOF
       if( @lang == BOAST::CUDA ) then
         module_file.print "#include <cuda_runtime.h>\n"
       end
-      module_file.print @procedure.header(@lang)
+      @procedure.boast_header(@lang)
       module_file.write <<EOF
 VALUE #{module_name} = Qnil;
 void Init_#{module_name}();

data/lib/BOAST/Case.rb

@@ -1,9 +1,8 @@
 module BOAST
 
-  class Case
-    def self.parens(*args,&block)
-      return self::new(*args,&block)
-    end
+  class Case < BOAST::ControlStructure
+    include BOAST::Inspectable
+    extend BOAST::Functor
 
     attr_reader :expression
     attr_reader :constants_list
@@ -28,88 +27,83 @@ module BOAST
       end
     end
 
-    def to_s(*args)
-      self.to_str(*args)
-    end
+    @@c_strings = {
+      :switch => '"switch (#{expr}) {"',
+      :case => '"case #{constants.join(" : case")} :"',
+      :default => '"default :"',
+      :break => '"break;"',
+      :end => '"}"'
+    }
 
-    def to_str(constants, first= true)
-      return self.to_str_fortran(constants, first) if BOAST::get_lang == FORTRAN
-      return self.to_str_c(constants, first) if [C, CL, CUDA].include?( BOAST::get_lang )
-    end
+    @@f_strings = {
+      :switch => '"select case (#{expr})"',
+      :case => '"case (#{constants.join(" : ")})"',
+      :default => '"case default"',
+      :break => 'nil',
+      :end => '"end select"'
+    }
+
+    @@strings = {
+      BOAST::C => @@c_strings,
+      BOAST::CL => @@c_strings,
+      BOAST::CUDA => @@c_strings,
+      BOAST::FORTRAN => @@f_strings
+    }
 
-    def to_str_fortran(constants, first)
+    eval token_string_generator( * %w{switch expr})
+    eval token_string_generator( * %w{case constants})
+    eval token_string_generator( * %w{default})
+    eval token_string_generator( * %w{break})
+    eval token_string_generator( * %w{end})
+
+    def to_s(block_number = nil)
       s = ""
-      if first then
-        s += " "*BOAST::get_indent_level
-        s += "select case (#{@expression})\n"
-        BOAST::increment_indent_level
-      else
-        BOAST::decrement_indent_level
-      end
-      s += " "*BOAST::get_indent_level
-      if constants and constants.size>0 then
-        s += "case (#{constants.join(" : ")})"
+      if block_number then
+        if block_number != 0 then
+          s += BOAST::indent + break_string + "\n" if break_string
+          BOAST::decrement_indent_level
+        end
+        s += BOAST::indent
+        if @constants_list[block_number] and @constants_list[block_number].size > 0 then
+          s += case_string(@constants_list[block_number])
+        else
+          s += default_string
+        end
       else
-        s += "case default"
+        s += BOAST::indent
+        s += switch_string(@expression)
       end
       BOAST::increment_indent_level
       return s
     end
 
-    def to_str_c(constants, first)
-      s = ""
-      if first then
-        s += " "*BOAST::get_indent_level
-        s += "switch(#{@expression}){\n"
-        BOAST::increment_indent_level
-      else
-        s += " "*BOAST::get_indent_level + "break;\n"
-        BOAST::decrement_indent_level
-      end
-      s += " "*BOAST::get_indent_level
-      if constants and constants.size>0 then
-        s += "case #{constants.join(" : case")} :"
-      else
-        s += "default :"
-      end
-      BOAST::increment_indent_level
-      return s
+    def open
+      BOAST::get_output.puts self.to_s
+      return self
     end
 
     def print(*args)
-      first = true
-      @blocks.each_index { |indx|
-        s = self.to_str(@constants_list[indx],first)
-        BOAST::get_output.puts s
-        @blocks[indx].call(*args)
-        first = false
-      }
-      self.close
+      self.open
+      if @blocks.size > 0 then
+        @blocks.each_index { |indx|
+          s = self.to_s(indx)
+          BOAST::get_output.puts s
+          @blocks[indx].call(*args)
+        }
+        self.close
+      end
       return self
     end
-    def close(final=true)
-      return self.close_fortran(final) if BOAST::get_lang == FORTRAN
-      return self.close_c(final) if [C, CL, CUDA].include?( BOAST::get_lang )
-    end
-    def close_c(final=true)
-      s = ""
-      s += " "*BOAST::get_indent_level if final
-      s += "break;\n"
-      BOAST::decrement_indent_level      
-      s += " "*BOAST::get_indent_level if final
-      s += "}"
-      BOAST::decrement_indent_level      
-      BOAST::get_output.puts s if final
-      return s
-    end
-    def close_fortran(final=true)
+
+    def close
       s = ""
+      s += BOAST::indent + break_string + "\n" if break_string
       BOAST::decrement_indent_level      
-      s += " "*BOAST::get_indent_level if final
-      s += "end select"
+      s += BOAST::indent
+      s += end_string
       BOAST::decrement_indent_level      
-      BOAST::get_output.puts s if final
-      return s
+      BOAST::get_output.puts s
+      return self
     end
 
   end 

data/lib/BOAST/ControlStructure.rb

@@ -0,0 +1,13 @@
+module BOAST
+
+  class ControlStructure
+    def self.token_string_generator(name, *args)
+       s = <<EOF
+    def #{name}_string(#{args.join(",")})
+      return eval @@strings[BOAST::get_lang][:#{name}] 
+    end
+EOF
+    end
+  end
+
+end