BOAST 0.9995 → 0.9996

data/lib/BOAST/CKernel.rb

@@ -8,7 +8,6 @@ require 'yaml'
 require 'pathname'
 
 module BOAST
-  @@verbose = false
   @@compiler_default_options = {
     :FC => 'gfortran',
     :FCFLAGS => '-O2 -Wall',
@@ -36,7 +35,16 @@ module BOAST
     "icpc" => "-openmp"
   }
 
-  def self.read_boast_config
+  module PrivateStateAccessor
+    private_boolean_state_accessor :verbose
+  end
+
+  boolean_state_accessor :verbose
+  @@verbose = false
+
+  module_function
+
+  def 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 )
@@ -70,36 +78,22 @@ module BOAST
     @@verbose = ENV["VERBOSE"] if ENV["VERBOSE"]
   end
 
-  BOAST::read_boast_config
+  read_boast_config
 
-  def self.get_openmp_flags
+  def get_openmp_flags
     return @@openmp_default_flags.clone
   end
 
-  def self.get_compiler_options
+  def get_compiler_options
     return @@compiler_default_options.clone
   end
 
-  def self.verbose
-    return @@verbose
-  end
-
-
-  def self.get_verbose
-    return @@verbose
-  end
-
-  def self.verbose=(verbose)
-    @@verbose = verbose
-  end
-
-  def self.set_verbose(verbose)
-    @@verbose = verbose
-  end
-
   class CKernel
     include Rake::DSL
-    include BOAST::Inspectable
+    include Inspectable
+    include PrivateStateAccessor
+    include TypeTransition
+
     attr_accessor :code
     attr_accessor :procedure
     attr_accessor :lang
@@ -110,13 +104,13 @@ module BOAST
     def initialize(options={})
       if options[:code] then
         @code = options[:code]
-      elsif BOAST::get_chain_code
-        @code = BOAST::get_output
+      elsif get_chain_code
+        @code = get_output
         @code.seek(0,SEEK_END)
       else
         @code = StringIO::new
       end
-      BOAST::set_output( @code )
+      set_output(@code)
       if options[:kernels] then
         @kernels = options[:kernels]
       else
@@ -125,7 +119,7 @@ module BOAST
       if options[:lang] then
         @lang = options[:lang]
       else
-        @lang = BOAST::get_lang
+        @lang = get_lang
       end
     end
 
@@ -139,29 +133,27 @@ module BOAST
       return code.read
     end
 
-    def setup_compiler(options = {})
-      Rake::Task::clear
-      verbose = options[:verbose]
-      verbose = BOAST::get_verbose if not verbose
-      Rake::verbose(verbose)
-      Rake::FileUtilsExt.verbose_flag=verbose
-      f_compiler = options[:FC]
-      c_compiler = options[:CC]
-      cxx_compiler = options[:CXX]
-      cuda_compiler = options[:NVCC]
-      f_flags = options[:FCFLAGS]
-      f_flags += " -fPIC"
-      f_flags += " -fno-second-underscore" if f_compiler == 'g95'
-      ld_flags = options[:LDFLAGS]
-      cuda_flags = options[:NVCCFLAGS]
-      cuda_flags += " --compiler-options '-fPIC'"
 
+    def get_openmp_flags(compiler)
+      openmp_flags = BOAST::get_openmp_flags[compiler]
+      if not openmp_flags then
+        keys = BOAST::get_openmp_flags.keys
+        keys.each { |k|
+          openmp_flags = BOAST::get_openmp_flags[k] if compiler.match(k)
+        }
+      end
+      return openmp_flags
+    end
 
+    def get_includes(narray_path)
       includes = "-I#{RbConfig::CONFIG["archdir"]}"
       includes += " -I#{RbConfig::CONFIG["rubyhdrdir"]} -I#{RbConfig::CONFIG["rubyhdrdir"]}/#{RbConfig::CONFIG["arch"]}"
       includes += " -I#{RbConfig::CONFIG["rubyarchhdrdir"]}" if RbConfig::CONFIG["rubyarchhdrdir"]
-      ld_flags += " -L#{RbConfig::CONFIG["libdir"]} #{RbConfig::CONFIG["LIBRUBYARG"]} -lrt"
-      ld_flags += " -lcudart" if @lang == BOAST::CUDA
+      includes += " -I#{narray_path}" if narray_path
+      return includes
+    end
+
+    def get_narray_path
       narray_path = nil
       begin
         spec = Gem::Specification::find_by_name('narray')
@@ -174,49 +166,96 @@ module BOAST
           narray_path = Gem.loaded_specs['narray'].full_gem_path
         end
       end
-      includes += " -I#{narray_path}" if narray_path
+    end
+
+    def setup_c_compiler(options, includes, narray_path, runner)
+      c_compiler = options[:CC]
       cflags = options[:CFLAGS]
-      cxxflags = options[:CXXFLAGS]
       cflags += " -fPIC #{includes}"
-      cxxflags += " -fPIC #{includes}"
       cflags += " -DHAVE_NARRAY_H" if narray_path
-      fcflags = f_flags
-      cudaflags = cuda_flags
+      if options[:openmp] and @lang == C then
+          openmp_cflags = get_openmp_flags(c_compiler)
+          raise "unkwown openmp flags for: #{c_compiler}" if not openmp_cflags
+          cflags += " #{openmp_cflags}"
+      end
 
+      rule '.o' => '.c' do |t|
+        c_call_string = "#{c_compiler} #{cflags} -c -o #{t.name} #{t.source}"
+        runner.call(t, c_call_string)
+      end
+    end
+
+    def setup_cxx_compiler(options, includes, runner)
+      cxx_compiler = options[:CXX]
+      cxxflags = options[:CXXFLAGS]
+      cxxflags += " -fPIC #{includes}"
+      if options[:openmp] and @lang == C then
+          openmp_cxxflags = get_openmp_flags(cxx_compiler)
+          raise "unkwown openmp flags for: #{cxx_compiler}" if not openmp_cxxflags
+          cxxflags += " #{openmp_cxxflags}"
+      end
+
+      rule '.o' => '.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)
+      f_compiler = options[:FC]
+      fcflags = options[:FCFLAGS]
+      fcflags += " -fPIC"
+      fcflags += " -fno-second-underscore" if f_compiler == 'g95'
+      if options[:openmp] and @lang == FORTRAN then
+          openmp_fcflags = get_openmp_flags(f_compiler)
+          raise "unkwown openmp flags for: #{f_compiler}" if not openmp_fcflags
+          fcflags += " #{openmp_fcflags}"
+      end
+
+      rule '.o' => '.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)
+      cuda_compiler = options[:NVCC]
+      cudaflags = options[:NVCCFLAGS]
+      cudaflags += " --compiler-options '-fPIC'"
+
+      rule '.o' => '.cu' do |t|
+        cuda_call_string = "#{cuda_compiler} #{cudaflags} -c -o #{t.name} #{t.source}"
+        runner.call(t, cuda_call_string)
+      end
+    end
+
+    def setup_linker(options)
+      ldflags = options[:LDFLAGS]
+      ldflags += " -L#{RbConfig::CONFIG["libdir"]} #{RbConfig::CONFIG["LIBRUBYARG"]} -lrt"
+      ldflags += " -lcudart" if @lang == CUDA
+      c_compiler = options[:CC]
+      c_compiler = "cc" if not c_compiler
+      linker = options[:LD]
+      linker = c_compiler if not linker
       if options[:openmp] then
-        case @lang
-        when BOAST::C
-          openmp_c_flags = BOAST::get_openmp_flags[c_compiler]
-          if not openmp_c_flags then
-            keys = BOAST::get_openmp_flags.keys
-            keys.each { |k|
-              openmp_c_flags = BOAST::get_openmp_flags[k] if c_compiler.match(k)
-            }
-          end
-          raise "unkwown openmp flags for: #{c_compiler}" if not openmp_c_flags
-          cflags += " #{openmp_c_flags}"
-          openmp_cxx_flags = BOAST::get_openmp_flags[cxx_compiler]
-          if not openmp_cxx_flags then
-            keys = BOAST::get_openmp_flags.keys
-            keys.each { |k|
-              openmp_cxx_flags = BOAST::get_openmp_flags[k] if cxx_compiler.match(k)
-            }
-          end
-          raise "unkwown openmp flags for: #{cxx_compiler}" if not openmp_cxx_flags
-          cxxflags += " #{openmp_cxx_flags}"
-        when BOAST::FORTRAN
-          openmp_f_flags = BOAST::get_openmp_flags[f_compiler]
-          if not openmp_f_flags then
-            keys = BOAST::get_openmp_flags.keys
-            keys.each { |k|
-              openmp_f_flags = BOAST::get_openmp_flags[k] if f_compiler.match(k)
-            }
-          end
-          raise "unkwown openmp flags for: #{f_compiler}" if not openmp_f_flags
-          fcflags += " #{openmp_f_flags}"
-        end
+        openmp_ldflags = get_openmp_flags(linker)
+        raise "unkwown openmp flags for: #{linker}" if not openmp_ldflags
+        ldflags += " #{openmp_ldflags}"
       end
 
+      return [linker, ldflags]
+    end
+
+    def setup_compilers(options = {})
+      Rake::Task::clear
+      verbose = options[:verbose]
+      verbose = get_verbose if not verbose
+      Rake::verbose(verbose)
+      Rake::FileUtilsExt.verbose_flag=verbose
+
+      narray_path = get_narray_path
+      includes = get_includes(narray_path)
+
       runner = lambda { |t, call_string|
         if verbose then
           sh call_string
@@ -230,26 +269,13 @@ module BOAST
         end
       }
 
-      rule '.o' => '.c' do |t|
-        c_call_string = "#{c_compiler} #{cflags} -c -o #{t.name} #{t.source}"
-        runner.call(t, c_call_string)
-      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)
 
-      rule '.o' => '.f90' do |t|
-        f_call_string = "#{f_compiler} #{fcflags} -c -o #{t.name} #{t.source}"
-        runner.call(t, f_call_string)
-      end
-
-      rule '.o' => '.cpp' do |t|
-        cxx_call_string = "#{cxx_compiler} #{cxxflags} -c -o #{t.name} #{t.source}"
-        runner.call(t, cxx_call_string)
-      end
+      return setup_linker(options)
 
-      rule '.o' => '.cu' do |t|
-        cuda_call_string = "#{cuda_compiler} #{cudaflags} -c -o #{t.name} #{t.source}"
-        runner.call(t, cuda_call_string)
-      end
-      return ld_flags
     end
 
     def select_cl_platform(options)
@@ -287,8 +313,32 @@ module BOAST
       return devices.first
     end
 
-    def build_opencl(options)
+    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])
@@ -299,81 +349,84 @@ module BOAST
         puts e.to_s
         puts program.build_status
         puts program.build_log
-        if options[:verbose] or BOAST::get_verbose then
+        if options[:verbose] or get_verbose then
           puts @code.string
         end
         raise "OpenCL Failed to build #{@procedure.name}"
       end
-      if options[:verbose] or BOAST::get_verbose then
+      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)
-      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|
-    if @procedure.parameters[i].dimension then
-      if @procedure.parameters[i].direction == :in then
+      return self
+    end
+
+    def create_opencl_array(arg, parameter)
+      if parameter.direction == :in then
         flags = OpenCL::Mem::Flags::READ_ONLY
-      elsif @procedure.parameters[i].direction == :out then
+      elsif parameter.direction == :out then
         flags = OpenCL::Mem::Flags::WRITE_ONLY
       else
         flags = OpenCL::Mem::Flags::READ_WRITE
       end
-      if @procedure.parameters[i].texture then
-        params[i] = @context.create_image_2D( OpenCL::ImageFormat::new( OpenCL::ChannelOrder::R, OpenCL::ChannelType::UNORM_INT8 ), args[i].size * args[i].element_size, 1, :flags => flags )
-#        if @procedure.parameters[i].direction == :inout or @procedure.parameters[i].direction == :in then
-          @queue.enqueue_write_image( params[i], args[i], :blocking => true )
-#        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
-        params[i] = @context.create_buffer( args[i].size * args[i].element_size, :flags => flags )
-#        if @procedure.parameters[i].direction == :inout or @procedure.parameters[i].direction == :in then
-          @queue.enqueue_write_buffer( params[i], args[i], :blocking => true )
-#        end
+        param = @context.create_buffer( arg.size * arg.element_size, :flags => flags )
+        @queue.enqueue_write_buffer( param, arg, :blocking => true )
       end
-    else
-      if @procedure.parameters[i].type.is_a?(Real) then
-        params[i] = OpenCL::Half::new(args[i]) if @procedure.parameters[i].type.size == 2
-        params[i] = OpenCL::Float::new(args[i]) if @procedure.parameters[i].type.size == 4
-        params[i] = OpenCL::Double::new(args[i]) if @procedure.parameters[i].type.size == 8
-      elsif @procedure.parameters[i].type.is_a?(Int) then
-        if @procedure.parameters[i].type.signed
-          params[i] = OpenCL::Char::new(args[i]) if @procedure.parameters[i].type.size == 1
-          params[i] = OpenCL::Short::new(args[i]) if @procedure.parameters[i].type.size == 2
-          params[i] = OpenCL::Int::new(args[i]) if @procedure.parameters[i].type.size == 4
-          params[i] = OpenCL::Long::new(args[i]) if @procedure.parameters[i].type.size == 8
-        else
-          params[i] = OpenCL::UChar::new(args[i]) if @procedure.parameters[i].type.size == 1
-          params[i] = OpenCL::UShort::new(args[i]) if @procedure.parameters[i].type.size == 2
-          params[i] = OpenCL::UInt::new(args[i]) if @procedure.parameters[i].type.size == 4
-          params[i] = OpenCL::ULong::new(args[i]) if @procedure.parameters[i].type.size == 8
-        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
-        params[i] = args[i]
+        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_opencl(options)
+      init_opencl(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])
   }
   event = @queue.enqueue_NDrange_kernel(@kernel, opts[:global_work_size], :local_work_size => opts[:local_work_size])
   @procedure.parameters.each_index { |i|
-    if @procedure.parameters[i].dimension then
-      if @procedure.parameters[i].texture then
-        if @procedure.parameters[i].direction == :inout or @procedure.parameters[i].direction == :out then
-          @queue.enqueue_read_image( params[i], args[i], :blocking => true )
-        end
-      else
-        if @procedure.parameters[i].direction == :inout or @procedure.parameters[i].direction == :out then
-          @queue.enqueue_read_buffer( params[i], args[i], :blocking => true )
-        end
-      end
+    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 = {}
@@ -387,75 +440,90 @@ EOF
     return self
     end
 
-    def build(options = {})
-      compiler_options = BOAST::get_compiler_options
-      compiler_options.update(options)
-      return build_opencl(compiler_options) if @lang == BOAST::CL
-      ldflags = self.setup_compiler(compiler_options)
-      extension = ".c" if @lang == BOAST::C
-      extension = ".cu" if @lang == BOAST::CUDA
-      extension = ".f90" if @lang == BOAST::FORTRAN
-#temporary
-      c_compiler = compiler_options[:CC]
-      c_compiler = "cc" if not c_compiler
-      linker = compiler_options[:LD]
-      linker = c_compiler if not linker
-#end temporary
-      if options[:openmp] then
-        openmp_ld_flags = BOAST::get_openmp_flags[linker]
-          if not openmp_ld_flags then
-            keys = BOAST::get_openmp_flags.keys
-            keys.each { |k|
-              openmp_ld_flags = BOAST::get_openmp_flags[k] if linker.match(k)
-            }
-          end
-          raise "unkwown openmp flags for: #{linker}" if not openmp_ld_flags
-          ldflags += " #{openmp_ld_flags}"
-      end
-      source_file = Tempfile::new([@procedure.name,extension])
-      path = source_file.path
-      target = path.chomp(File::extname(path))+".o"
-      fill_code(source_file)
-      source_file.close
+    @@extensions = {
+      C => ".c",
+      CUDA => ".cu",
+      FORTRAN => ".f90"
+    }
 
-      previous_lang = BOAST::get_lang
-      previous_output = BOAST::get_output
-      BOAST::set_lang(BOAST::C)
+    def get_sub_kernels
+      kernel_files = []
+      @kernels.each { |kernel|
+        kernel_file = Tempfile::new([kernel.procedure.name,".o"])
+        kernel.binary.rewind
+        kernel_file.write( kernel.binary.read )
+        kernel_file.close
+        kernel_files.push(kernel_file)
+      }
+    end
+
+    def create_module_source(path)
+      previous_lang = get_lang
+      previous_output = get_output
+      set_lang( C )
       module_file_name = File::split(path.chomp(File::extname(path)))[0] + "/Mod_" + File::split(path.chomp(File::extname(path)))[1].gsub("-","_") + ".c"
       module_name = File::split(module_file_name.chomp(File::extname(module_file_name)))[1]
       module_file = File::open(module_file_name,"w+")
-      BOAST::set_output(module_file)
+      set_output( module_file )
       fill_module(module_file, module_name)
       module_file.rewind
      #puts module_file.read
       module_file.close
-      BOAST::set_lang(previous_lang)
-      BOAST::set_output(previous_output)
+      set_lang( previous_lang )
+      set_output( previous_output )
+      return [module_file_name, module_name]
+    end
+
+    def save_binary(target)
+      f = File::open(target,"rb")
+      @binary = StringIO::new
+      @binary.write( f.read )
+      f.close
+    end
+
+    def create_source
+      extension = @@extensions[@lang]
+      source_file = Tempfile::new([@procedure.name,extension])
+      path = source_file.path
+      target = path.chomp(File::extname(path))+".o"
+      fill_code(source_file)
+      source_file.close
+      return [source_file, path, target]
+    end
+
+    def build(options = {})
+      compiler_options = BOAST::get_compiler_options
+      compiler_options.update(options)
+      return build_opencl(compiler_options) if @lang == CL
+
+      linker, ldflags = setup_compilers(compiler_options)
+
+      extension = @@extensions[@lang]
+
+      source_file, path, target = create_source
+
+      module_file_name, module_name = create_module_source(path)
+
       module_target = module_file_name.chomp(File::extname(module_file_name))+".o"
       module_final = module_file_name.chomp(File::extname(module_file_name))+".so"
-      kernel_files = []
-      @kernels.each { |kernel|
-        kernel_file = Tempfile::new([kernel.procedure.name,".o"])
-        kernel.binary.rewind
-        kernel_file.write( kernel.binary.read )
-        kernel_file.close
-        kernel_files.push(kernel_file)
-      }
+
+
+      kernel_files = get_sub_kernels
+
       file module_final => [module_target, target] do
         #puts "#{linker} -shared -o #{module_final} #{module_target} #{target} #{kernel_files.join(" ")} -Wl,-Bsymbolic-functions -Wl,-z,relro -rdynamic -Wl,-export-dynamic #{ldflags}"
         sh "#{linker} -shared -o #{module_final} #{module_target} #{target} #{(kernel_files.collect {|f| f.path}).join(" ")} -Wl,-Bsymbolic-functions -Wl,-z,relro -rdynamic -Wl,-export-dynamic #{ldflags}"
       end
       Rake::Task[module_final].invoke
+
       require(module_final)
       eval "self.extend(#{module_name})"
-      f = File::open(target,"rb")
-      @binary = StringIO::new
-      @binary.write( f.read )
-      f.close
-      File.unlink(target)
-      File.unlink(module_target)
-      File.unlink(module_file_name)
-      File.unlink(module_final)
+
+      save_binary(target)
+
+      [target, module_target, module_file_name, module_final].each { |fn|
+        File::unlink(fn)
+      }
       kernel_files.each { |f|
         f.unlink
       }
@@ -464,13 +532,13 @@ EOF
 
     def fill_code(source_file)
       @code.rewind
-      source_file.puts "#include <inttypes.h>" if @lang == BOAST::C or @lang == BOAST::CUDA
-      source_file.puts "#include <cuda.h>" if @lang == BOAST::CUDA
+      source_file.puts "#include <inttypes.h>" if @lang == C or @lang == CUDA
+      source_file.puts "#include <cuda.h>" if @lang == CUDA
       source_file.write @code.read
-      if @lang == BOAST::CUDA then
+      if @lang == CUDA then
         source_file.write <<EOF
 extern "C" {
-  #{@procedure.boast_header_s(BOAST::CUDA)}{
+  #{@procedure.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]);
     cudaEvent_t __start, __stop;
@@ -490,8 +558,8 @@ EOF
       @code.rewind
     end
 
-    def fill_module(module_file, module_name)
-      module_file.write <<EOF
+    def module_header(module_file)
+      module_file.print <<EOF
 #include "ruby.h"
 #include <inttypes.h>
 #include <time.h>
@@ -499,11 +567,13 @@ EOF
 #include "narray.h"
 #endif
 EOF
-      if( @lang == BOAST::CUDA ) then
+      if( @lang == CUDA ) then
         module_file.print "#include <cuda_runtime.h>\n"
       end
-      @procedure.boast_header(@lang)
-      module_file.write <<EOF
+    end
+
+    def module_preamble(module_file, module_name)
+      module_file.print <<EOF
 VALUE #{module_name} = Qnil;
 void Init_#{module_name}();
 VALUE method_run(int argc, VALUE *argv, VALUE self);
@@ -511,46 +581,37 @@ void Init_#{module_name}() {
   #{module_name} = rb_define_module("#{module_name}");
   rb_define_method(#{module_name}, "run", method_run, -1);
 }
-VALUE method_run(int argc, VALUE *argv, VALUE self) {
 EOF
-      if( @lang == BOAST::CUDA ) then
-        module_file.write <<EOF
+    end
+
+    def check_args(module_file)
+      if @lang == CUDA then
+        module_file.print <<EOF
   if( argc < #{@procedure.parameters.length} || argc > #{@procedure.parameters.length + 1} )
     rb_raise(rb_eArgError, "wrong number of arguments for #{@procedure.name} (%d for #{@procedure.parameters.length})", argc);
-  VALUE rb_opts;
-  VALUE rb_ptr;
-  size_t block_size[3] = {1,1,1};
-  size_t block_number[3] = {1,1,1};
 EOF
       else
-        module_file.write <<EOF
+        module_file.print <<EOF
   if( argc != #{@procedure.parameters.length} )
     rb_raise(rb_eArgError, "wrong number of arguments for #{@procedure.name} (%d for #{@procedure.parameters.length})", argc);
-  VALUE rb_ptr;
 EOF
       end
-      argc = @procedure.parameters.length
-      argv = Variable::new("argv",Real,{:dimension => [ Dimension::new(0,argc-1) ] })
-      rb_ptr = Variable::new("rb_ptr",Int)
-      @procedure.parameters.each { |param| 
-        param_copy = param.copy
-        param_copy.constant = nil
-        param_copy.direction = nil
-        param_copy.decl
-      }
+    end
+
+    def get_params_value(module_file, argv, rb_ptr)
       @procedure.parameters.each_index do |i|
         param = @procedure.parameters[i]
         if not param.dimension then
           case param.type
-            when Int 
-              (param === FuncCall::new("NUM2INT", argv[i])).print if param.type.size == 4
-              (param === FuncCall::new("NUM2LONG", argv[i])).print if param.type.size == 8
-            when Real
-              (param === FuncCall::new("NUM2DBL", argv[i])).print
+          when Int 
+            (param === FuncCall::new("NUM2INT", argv[i])).pr if param.type.size == 4
+            (param === FuncCall::new("NUM2LONG", argv[i])).pr if param.type.size == 8
+          when Real
+            (param === FuncCall::new("NUM2DBL", argv[i])).pr
           end
         else
-          (rb_ptr === argv[i]).print
-          if @lang == BOAST::CUDA then
+          (rb_ptr === argv[i]).pr
+          if @lang == CUDA then
             module_file.print <<EOF
   if ( IsNArray(rb_ptr) ) {
     struct NARRAY *n_ary;
@@ -558,16 +619,9 @@ EOF
     Data_Get_Struct(rb_ptr, struct NARRAY, n_ary);
     array_size = n_ary->total * na_sizeof[n_ary->type];
     cudaMalloc( (void **) &#{param.name}, array_size);
-EOF
-#            if param.direction == :in then
-            module_file.print <<EOF
     cudaMemcpy(#{param.name}, (void *) n_ary->ptr, array_size, cudaMemcpyHostToDevice);
-EOF
-#            end
-            module_file.print <<EOF
   } else
     rb_raise(rb_eArgError, "wrong type of argument %d", #{i});
-  
 EOF
           else
             module_file.print <<EOF
@@ -583,8 +637,26 @@ EOF
           end
         end
       end
-      if @lang == BOAST::CUDA then
-        module_file.write <<EOF
+    end
+
+    def decl_module_params(module_file)
+      @procedure.parameters.each { |param| 
+        param_copy = param.copy
+        param_copy.constant = nil
+        param_copy.direction = nil
+        param_copy.decl
+      }
+      module_file.print "  #{@procedure.properties[:return].type.decl} ret;\n" if @procedure.properties[:return]
+      module_file.print "  VALUE stats = rb_hash_new();\n"
+      module_file.print "  struct timespec start, stop;\n"
+      module_file.print "  unsigned long long int duration;\n"
+    end
+
+    def get_cuda_launch_bounds(module_file)
+      module_file.print <<EOF
+  VALUE rb_opts;
+  size_t block_size[3] = {1,1,1};
+  size_t block_number[3] = {1,1,1};
   if( argc == #{@procedure.parameters.length + 1} ) {
     rb_opts = argv[argc -1];
     if ( rb_opts != Qnil ) {
@@ -615,23 +687,20 @@ EOF
     }
   }
 EOF
-      end
-      module_file.print "  #{@procedure.properties[:return].type.decl} ret;\n" if @procedure.properties[:return]
-      module_file.print "  VALUE stats = rb_hash_new();\n"
-      module_file.print "  struct timespec start, stop;\n"
-      module_file.print "  unsigned long long int duration;\n"
-      module_file.print "  clock_gettime(CLOCK_REALTIME, &start);\n"
-      if @lang == BOAST::CUDA then
+    end
+
+    def create_procedure_call(module_file)
+      if @lang == CUDA then
         module_file.print "  duration = "
       elsif @procedure.properties[:return] then
         module_file.print "  ret = "
       end
       module_file.print "  #{@procedure.name}"
-      module_file.print "_" if @lang == BOAST::FORTRAN
-      module_file.print "_wrapper" if @lang == BOAST::CUDA
+      module_file.print "_" if @lang == FORTRAN
+      module_file.print "_wrapper" if @lang == CUDA
       module_file.print "("
       params = []
-      if(@lang == BOAST::FORTRAN) then
+      if(@lang == FORTRAN) then
         @procedure.parameters.each { |param|
           if param.dimension then
             params.push( param.name )
@@ -650,18 +719,19 @@ EOF
           end
         }
       end
-      if @lang == BOAST::CUDA then
+      if @lang == CUDA then
         params.push( "block_number", "block_size" )
       end
       module_file.print params.join(", ")
       module_file.print "  );\n"
-      module_file.print "  clock_gettime(CLOCK_REALTIME, &stop);\n"
+    end
 
-      if @lang == BOAST::CUDA then
+    def get_results(module_file, argv, rb_ptr)
+      if @lang == CUDA then
         @procedure.parameters.each_index do |i|
           param = @procedure.parameters[i]
           if param.dimension then
-            (rb_ptr === argv[i]).print
+            (rb_ptr === argv[i]).pr
             module_file.print <<EOF
   if ( IsNArray(rb_ptr) ) {
 EOF
@@ -683,7 +753,10 @@ EOF
           end
         end
       end
-      if @lang != BOAST::CUDA then
+    end
+
+    def store_result(module_file)
+      if @lang != CUDA then
         module_file.print "  duration = (unsigned long long int)stop.tv_sec * (unsigned long long int)1000000000 + stop.tv_nsec;\n"
         module_file.print "  duration -= (unsigned long long int)start.tv_sec * (unsigned long long int)1000000000 + start.tv_nsec;\n"
       end
@@ -694,14 +767,49 @@ EOF
         module_file.print "  rb_hash_aset(stats,ID2SYM(rb_intern(\"return\")),rb_int_new((unsigned long long)ret));\n" if type_ret.kind_of?(Int) and not type_ret.signed
         module_file.print "  rb_hash_aset(stats,ID2SYM(rb_intern(\"return\")),rb_float_new((double)ret));\n" if type_ret.kind_of?(Real)
       end
+    end
+
+    def fill_module(module_file, module_name)
+      module_header(module_file)
+      @procedure.boast_header(@lang)
+      module_preamble(module_file, module_name)
+
+      module_file.puts "VALUE method_run(int argc, VALUE *argv, VALUE self) {"
+
+      check_args(module_file)
+
+      argc = @procedure.parameters.length
+      argv = Variable::new("argv", CustomType, :type_name => "VALUE", :dimension => [ Dimension::new(0,argc-1) ] )
+      rb_ptr = Variable::new("rb_ptr", CustomType, :type_name => "VALUE")
+      set_transition("VALUE", "VALUE", :default,  CustomType::new(:type_name => "VALUE"))
+      rb_ptr.decl
+
+      decl_module_params(module_file)
+
+      get_params_value(module_file, argv, rb_ptr)
+
+      if @lang == CUDA then
+        module_file.print get_cuda_launch_bounds(module_file)
+      end
+
+      module_file.print "  clock_gettime(CLOCK_REALTIME, &start);\n"
+
+      create_procedure_call(module_file)
+
+      module_file.print "  clock_gettime(CLOCK_REALTIME, &stop);\n"
+
+      get_results(module_file, argv, rb_ptr)
+
+      store_result(module_file)
+
       module_file.print "  return stats;\n"
-      module_file.print  "}"
+      module_file.print "}"
     end
 
     def method_missing(meth, *args, &block)
      if meth.to_s == "run" then
-       self.build
-       self.run(*args,&block)
+       build
+       run(*args,&block)
      else
        super
      end
@@ -737,6 +845,104 @@ EOF
       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 = {}
@@ -749,89 +955,10 @@ EOF
       dirs.each { |d|
         res = [] 
         @procedure.parameters.collect { |param|
-          if intent == :out and ( param.direction == :in or param.constant ) then
-            res.push nil
-            next
-          end
-          f = File::new( d+"/"+param.name+suffix, "rb" )
-          if param.dimension then
-            if param.type.class == BOAST::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 BOAST::debug
-                type = NArray::BYTE
-              end
-            elsif param.type.class == BOAST::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 BOAST::debug
-                type = NArray::BYTE
-              end
-            else
-              STDERR::puts "Unkown array type for NArray: #{param.type}, defaulting to byte" if BOAST::debug
-              type = NArray::BYTE
-            end
-            if f.size == 0 then
-              res.push NArray::new(type, 1)
-            else
-              res.push NArray.to_na(f.read, type)
-            end
-          else
-            if param.type.class == BOAST::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 == BOAST::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
-            res.push f.read.unpack(type).first
-          end
-          f.close
+          res.push read_param(param, d, suffix, intent)
         }
-        if @lang == BOAST::CUDA or @lang == BOAST::CL then
-          f = File::new( d +"/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 == BOAST::CL then
-            local_dim.each_index { |indx| global_dim[indx] *= local_dim[indx] }
-            res.push( { :global_work_size => global_dim, :local_work_size => local_dim } )
-          else
-            res.push( { :block_number => global_dim, :block_size => local_dim } )
-          end
-          f.close
+        if @lang == CUDA or @lang == CL then
+          res.push get_gpu_dim(d)
         end
         res_h[d] =  res
       }