BOAST 1.3.4 → 1.3.5

data/lib/BOAST/Language/Config.rb

@@ -135,6 +135,16 @@ module BOAST
     return use_vla_old?
   end
 
+  def set_model(val)
+    @@model=val
+    Intrinsics::generate_conversions
+  end
+
+  def model=(val)
+    @@model=val
+    Intrinsics::generate_conversions
+  end
+
   # @private
   def get_default_architecture
     architecture = const_get(ENV["ARCHITECTURE"]) if ENV["ARCHITECTURE"]

data/lib/BOAST/Language/Intrinsics.rb

@@ -66,8 +66,27 @@ module BOAST
       end
       raise IntrinsicsError, "Unsupported operation #{intr_symbol} for #{type}#{type2 ? " and #{type2}" : ""} on #{get_architecture_name}!" unless instruction
       return instruction if get_architecture == ARM
-      supported = (INSTRUCTIONS[instruction.to_s] & MODELS[get_model.to_s]).size > 0
-      raise IntrinsicsError, "Unsupported operation #{intr_symbol} for #{type}#{type2 ? " and #{type2}" : ""} on #{get_model}! (requires #{INSTRUCTIONS[instruction.to_s].join(" or ")})" unless supported
+      supported = false
+      INSTRUCTIONS[instruction.to_s].each { |cpuid|
+        if cpuid.kind_of?( Array ) then
+          supported = true if (cpuid - MODELS[get_model.to_s]).empty?
+        else
+          supported = true if MODELS[get_model.to_s].include?( cpuid )
+        end
+      }
+#      supported = (INSTRUCTIONS[instruction.to_s] & MODELS[get_model.to_s]).size > 0
+      if not supported then
+        required = ""
+        INSTRUCTIONS[instruction.to_s].each { |cpuid|
+          required += " or " if required != ""
+          if cpuid.kind_of?( Array ) then
+            required += "( #{cpuid.join(" and ")} )"
+          else
+            required += "#{cpuid}"
+          end
+        }
+        raise IntrinsicsError, "Unsupported operation #{intr_symbol} for #{type}#{type2 ? " and #{type2}" : ""} on #{get_model}! (requires #{required})"
+      end
       return instruction
     end
 
@@ -81,14 +100,14 @@ module BOAST
 
     def get_conversion_path(type_dest, type_orig)
       conversion_path = CONVERSIONS[get_architecture][get_vector_name(type_dest)][get_vector_name(type_orig)]
-      raise IntrinsicsError, "Unavailable conversion from #{get_vector_name(type_orig)} to #{get_vector_name(type_dest)} on #{get_architecture_name}!" unless conversion_path
+      raise IntrinsicsError, "Unavailable conversion from #{get_vector_name(type_orig)} to #{get_vector_name(type_dest)} on #{get_architecture_name}#{get_architecture==X86 ? "(#{get_model})" : "" }!" unless conversion_path
       return conversion_path
     end
 
     module_function :get_conversion_path
 
     def get_vector_decl_X86( data_type )
-      raise IntrinsicsError, "Unsupported vector size on X86: #{data_type.total_size*8}!" unless [64,128,256].include?( data_type.total_size*8 )
+      raise IntrinsicsError, "Unsupported vector size on X86: #{data_type.total_size*8}!" unless [64,128,256,512].include?( data_type.total_size*8 )
       s = "__m#{data_type.total_size*8}"
       case data_type
       when Int
@@ -112,7 +131,7 @@ module BOAST
         raise IntrinsicsError, "Unsupported data size for int vector on ARM: #{data_type.size*8}!" unless [1,2,4,8].include?( data_type.size )
         return get_vector_name( data_type ).to_s
       when Real
-        raise IntrinsicsError, "Unsupported data size for real vector on ARM: #{data_type.size*8}!" if data_type.size != 4
+        raise IntrinsicsError, "Unsupported data size for real vector on ARM: #{data_type.size*8}!" unless [4,8].include?( data_type.size )
         return get_vector_name( data_type ).to_s
       else
         raise IntrinsicsError, "Unsupported data type #{data_type} for vector on ARM!"
@@ -244,10 +263,11 @@ module BOAST
           instructions.push( [:SET, "setr"] ) unless size < 32 and vector_size == 512
           instructions.push( [:SET1, "set1"] )
           instructions.push( [:MUL, "mullo"] ) if vector_size > 64 and size >= 16
-          instructions.push( [:MASKLOAD, "maskload"], [:MASKSTORE, "maskstore"] ) if vector_size <= 256 and vector_size >= 128 and size >= 32
-          instructions.push( [:MASK_LOAD,  "mask_load"],   [:MASK_STORE,  "mask_store"],
-                             [:MASK_LOADU, "mask_loadu"],  [:MASK_STOREU, "mask_storeu"],
-                             [:MASKZ_LOAD, "maskz_load"],  [:MASKZ_LOADU, "maskz_loadu"], ) if vector_size >= 128 and size >= 32
+          instructions.push( [:MASKLOAD,    "maskload"],    [:MASKSTORE, "maskstore"] ) if vector_size <= 256 and vector_size >= 128 and size >= 32
+          instructions.push( [:MASK_LOAD,   "mask_loadu"],  [:MASK_STORE,  "mask_storeu"],
+                             [:MASK_LOADA,  "mask_load"],   [:MASK_STOREA, "mask_store"],
+                             [:MASKZ_LOAD,  "maskz_loadu"],
+                             [:MASKZ_LOADA, "maskz_load"], ) if vector_size >= 128 and size >= 32
           instructions.each { |cl, ins|
             INTRINSICS[X86][cl][vtype] = "_mm#{vs}_#{ins}_#{type}".to_sym
           }
@@ -278,9 +298,10 @@ module BOAST
                         [:LOAD, "loadu"],        [:LOADA, "load"],
                         [:STORE, "storeu"],  [:STOREA, "store"],
                         [:SET, "setr"],      [:SET1, "set1"], [:SETZERO, "setzero"],
-                        [:MASK_LOAD,  "mask_load"],  [:MASK_STORE,  "mask_store"],
-                        [:MASK_LOADU, "mask_loadu"], [:MASK_STOREU, "mask_storeu"],
-                        [:MASKZ_LOAD, "maskz_load"], [:MASKZ_LOADU, "maskz_loadu"] ]
+                        [:MASK_LOAD,   "mask_loadu"],  [:MASK_STORE,  "mask_storeu"],
+                        [:MASK_LOADA,  "mask_load"],   [:MASK_STOREA, "mask_store"],
+                        [:MASKZ_LOAD,  "maskz_loadu"],
+                        [:MASKZ_LOADA, "maskz_load"]]
         instructions.push( [:MASKLOAD, "maskload"], [:MASKSTORE, "maskstore"] ) if vector_size < 512
         instructions.push( [:ADDSUB, "addsub"] ) if vector_size < 512
         instructions.each { |cl, ins|
@@ -362,7 +383,7 @@ module BOAST
           }
         }
       }
-      [32].each { |size|
+      [32, 64].each { |size|
         vtype = vector_type_name( :float, size, vector_size )
         type = type_name_ARM( :float, size )
         [[:ADD, "add"], [:SUB, "sub"], [:MUL, "mul"],
@@ -381,18 +402,24 @@ module BOAST
     }
     INTRINSICS[ARM][:CVT] = Hash::new { |h,k| h[k] = {} }
     [64, 128].each { |vector_size|
-      int_size = 32
-      float_size = 32
-      q = (vector_size == 128 ? "q" : "")
-      [:signed, :unsigned].each { |sign|
-        fvtype = vector_type_name( :float, float_size, vector_size )
-        ivtype = vector_type_name( :int, int_size, vector_size, sign )
-        ftype = type_name_ARM( :float, float_size )
-        itype = type_name_ARM( :int, int_size, sign )
-        INTRINSICS[ARM][:CVT][ivtype][fvtype] = "vcvt#{q}_#{itype}_#{ftype}".to_sym
-        INTRINSICS[ARM][:CVT][fvtype][ivtype] = "vcvt#{q}_#{ftype}_#{itype}".to_sym
+      [[32, 32],[64, 64]].each { |int_size, float_size|
+        q = (vector_size == 128 ? "q" : "")
+        [:signed, :unsigned].each { |sign|
+          fvtype = vector_type_name( :float, float_size, vector_size )
+          ivtype = vector_type_name( :int, int_size, vector_size, sign )
+          ftype = type_name_ARM( :float, float_size )
+          itype = type_name_ARM( :int, int_size, sign )
+          INTRINSICS[ARM][:CVT][ivtype][fvtype] = "vcvt#{q}_#{itype}_#{ftype}".to_sym
+          INTRINSICS[ARM][:CVT][fvtype][ivtype] = "vcvt#{q}_#{ftype}_#{itype}".to_sym
+        }
       }
     }
+    sfvtype = vector_type_name( :float, 32, 64 )
+    sdvtype = vector_type_name( :float, 64, 128 )
+    sftype = type_name_ARM( :float, 32 )
+    sdtype = type_name_ARM( :float, 64 )
+    INTRINSICS[ARM][:CVT][sfvtype][sdvtype] = "vcvt_#{sftype}_#{sdtype}".to_sym
+    INTRINSICS[ARM][:CVT][sdvtype][sfvtype] = "vcvt_#{sdtype}_#{sftype}".to_sym
     svsize = 64
     bvsize = 128
     [16, 32, 64].each { |bsize|
@@ -407,30 +434,46 @@ module BOAST
       }
     }
 
-    [X86, ARM].each { |arch|
-      cvt_dgraph = RGL::DirectedAdjacencyGraph::new
-      INTRINSICS[arch][:CVT].each { |dest, origs|
-        origs.each { |orig, intrinsic|
-          cvt_dgraph.add_edge(orig, dest)
+    def generate_conversions
+      [X86, ARM].each { |arch|
+        cvt_dgraph = RGL::DirectedAdjacencyGraph::new
+        INTRINSICS[arch][:CVT].each { |dest, origs|
+          origs.each { |orig, intrinsic|
+            supported = true
+            if arch == X86
+              supported = false
+              INSTRUCTIONS[intrinsic.to_s].each { |cpuid|
+                if cpuid.kind_of?( Array ) then
+                  supported = true if (cpuid - MODELS[get_model.to_s]).empty?
+                else
+                  supported = true if MODELS[get_model.to_s].include?( cpuid )
+                end
+              }
+            end
+            cvt_dgraph.add_edge(orig, dest) if supported
+          }
         }
-      }
-      cvt_dgraph.vertices.each { |source|
-        hash = {}
-        cvt_dgraph.edges.each { |e| hash[e.to_a] = 1 }
-        paths = cvt_dgraph.dijkstra_shortest_paths( hash, source )
-        paths.each { |dest, path|
-          CONVERSIONS[arch][dest][source] = path if path
+        cvt_dgraph.vertices.each { |source|
+          hash = {}
+          cvt_dgraph.edges.each { |e| hash[e.to_a] = 1 }
+          paths = cvt_dgraph.dijkstra_shortest_paths( hash, source )
+          paths.each { |dest, path|
+            CONVERSIONS[arch][dest][source] = path if path
+          }
+        }
+        types = []
+        INTRINSICS[arch].each { |intrinsic, instructions|
+          types += instructions.keys
+        }
+        types.uniq
+        types.each { |type|
+          CONVERSIONS[arch][type][type] = [type]
         }
       }
-      types = []
-      INTRINSICS[arch].each { |intrinsic, instructions|
-        types += instructions.keys
-      }
-      types.uniq
-      types.each { |type|
-        CONVERSIONS[arch][type][type] = [type]
-      }
-    }
+    end
+    module_function :generate_conversions
+
+    generate_conversions
 
   end
 

data/lib/BOAST/Language/Operators.rb

@@ -192,7 +192,7 @@ module BOAST
       if arg1.class == Variable and arg1.type.vector_length > 1 then
         return "#{arg1} = #{Load(arg2, arg1)}"
       elsif arg2.class == Variable and arg2.type.vector_length > 1 then
-        return "#{Store(arg1, arg2, return_type)}"
+        return "#{Store(arg1, arg2, :store_type => return_type)}"
       end
       return basic_usage(arg1, arg2)
     end
@@ -304,6 +304,61 @@ module BOAST
 
   end
 
+  class Mask
+    extend Functor
+
+    attr_reader :value
+    attr_reader :length
+    attr_reader :pos_values
+
+    def empty?
+      if @pos_values then
+        return @pos_values == 0
+      else
+        return false
+      end
+    end
+
+    def full?
+      if @pos_values and @length
+        return @pos_values == @length
+      else
+        return false
+      end
+    end
+
+    def initialize( values, options = {} )
+      length = options[:length]
+      if values.kind_of?(Mask) then
+        raise OperatorError, "Wrong number of mask values (#{values.length} for #{length})!" if length and values.length and values.length != length
+        @value = values.value
+        @length = length ? length : values.length
+        @pos_values = values.pos_values
+      elsif values.kind_of?(Array) then
+        raise OperatorError, "Wrong number of mask values (#{values.length} for #{length})!" if length and values.length != length
+        s = "0x"
+        s += values.collect { |v| v != 0 ? 1 : 0 }.reverse.join
+        @value = Int( s, :signed => false, :size => values.length / 8 + ( values.length % 8 > 0 ? 1 : 0 ), :constant => s )
+        @length = values.length
+        @pos_values = values.reject { |e| e == 0 }.length
+      elsif values.kind_of?(Variable) and values.type.kind_of?(Int) then
+        raise OperatorError, "Wrong mask size (#{values.type.size} for #{length / 8 + ( length % 8 > 0 ? 1 : 0 )})!" if length and values.type.size != length / 8 + ( length % 8 > 0 ? 1 : 0 )
+        @value = values
+        @length = length if length
+      else
+        raise OperatorError, "Illegal valuess for mask (#{values.class}), expecting Array of Int!"
+      end
+    end
+
+    def to_s
+      return @value.to_s
+    end
+
+    def to_var
+      return @value
+    end
+  end
+
   # @!parse module Functors; functorize Set; end
   class Set < Operator
     extend Functor
@@ -386,10 +441,14 @@ module BOAST
 
     attr_reader :source
     attr_reader :return_type
+    attr_reader :options
 
-    def initialize(source, return_type)
+    def initialize(source, return_type, options = {})
       @source = source
       @return_type = return_type.to_var
+      @options = options
+      @mask = options[:mask]
+      @zero = options[:zero]
     end
 
     def type
@@ -412,10 +471,25 @@ module BOAST
             end
             return @return_type.copy("vload#{@return_type.type.vector_length}(0, #{a2})", DISCARD_OPTIONS) if lang == CL
             return @return_type.copy("_m_from_int64( *((int64_t * ) #{a2} ) )", DISCARD_OPTIONS) if get_architecture == X86 and @return_type.type.total_size*8 == 64
+            sym = ""
+            mask = nil
+            mask = Mask(@mask, :length => @return_type.type.vector_length) if @mask
+            if mask and not mask.full? then
+              return Set(0, @return_type) if @zero and mask.empty?
+              return @return_type if mask.empty?
+              sym += "MASK"
+              sym += "Z" if @zero
+              sym += "_"
+            end
             if @source.alignment and @return_type.type.total_size and ( @source.alignment % @return_type.type.total_size ) == 0 then
-              instruction = intrinsics(:LOADA, @return_type.type)
+              sym += "LOADA"
             else
-              instruction = intrinsics(:LOAD, @return_type.type)
+              sym += "LOAD"
+            end
+            instruction = intrinsics( sym.to_sym, @return_type.type)
+            if mask and not mask.full? then
+              return @return_type.copy("#{instruction}( (#{mask.value.type.decl})#{mask}, #{a2} )", DISCARD_OPTIONS) if @zero
+              return @return_type.copy("#{instruction}( #{@return_type}, (#{mask.value.type.decl})#{mask}, #{a2} )", DISCARD_OPTIONS)
             end
             return @return_type.copy("#{instruction}( #{a2} )", DISCARD_OPTIONS)
           else
@@ -516,12 +590,14 @@ module BOAST
     attr_reader :dest
     attr_reader :source
     attr_reader :store_type
+    attr_reader :options
 
-    def initialize(dest, source, store_type = nil)
+    def initialize(dest, source, options = {})
       @dest = dest
       @source = source
-      @store_type = store_type
+      @store_type = options[:store_type]
       @store_type = source.to_var unless @store_type
+      @mask = options[:mask]
     end
 
     def to_s
@@ -535,14 +611,20 @@ module BOAST
         type = @store_type.type
         return "vstore#{type.vector_length}( #{@source}, 0, #{dst} )" if lang == CL
         return "*((int64_t * ) #{dst}) = _m_to_int64( #{@source} )" if get_architecture == X86 and type.total_size*8 == 64
-
+        sym = ""
+        mask = nil
+        mask = Mask(@mask, :length => @store_type.type.vector_length) if @mask
+        return "" if mask and mask.empty?
+        sym += "MASK_" if mask and not mask.full?
         if @dest.alignment and type.total_size and ( @dest.alignment % type.total_size ) == 0 then
-          instruction = intrinsics(:STOREA, type)
+          sym += "STOREA"
         else
-          instruction = intrinsics(:STORE, type)
+          sym += "STORE"
         end
+        instruction = intrinsics(sym.to_sym, type)
         p_type = type.copy(:vector_length => 1)
         p_type = type if get_architecture == X86 and type.kind_of?(Int)
+        return "#{instruction}( (#{p_type.decl} * ) #{dst}, (#{mask.value.type.decl})#{mask}, #{@source} )" if mask and not mask.full?
         return "#{instruction}( (#{p_type.decl} * ) #{dst}, #{@source} )"
       end
       return Affectation.basic_usage(@dest, @source)
@@ -592,7 +674,7 @@ module BOAST
       type = @store_type.type
       raise LanguageError,  "Unsupported language!" unless lang == C
       raise OperatorError,  "Mask size is wrong: #{@mask.length} for #{type.vector_length}!" if @mask.length != type.vector_length
-      return Store( @dest, @source, @store_type ).to_s unless @mask.include?(0)
+      return Store( @dest, @source, :store_type => @store_type ).to_s unless @mask.include?(0)
       return nil if @mask.uniq.size == 1 and @mask.uniq.first == 0
       instruction = intrinsics(:MASKSTORE, type)
       s = ""

data/lib/BOAST/Language/Variable.rb

@@ -179,6 +179,7 @@ module BOAST
     attr_reader :restrict
     attr_reader :deferred_shape
     attr_reader :optional
+    attr_accessor :reference
     attr_accessor :alignment
     attr_accessor :replace_constant
     attr_accessor :force_replace_constant
@@ -231,6 +232,10 @@ module BOAST
       !!@deferred_shape
     end
 
+    def reference?
+      !!@reference
+    end
+
     # Creates a new {Variable}
     # @param [#to_s] name
     # @param [DataType] type
@@ -239,6 +244,7 @@ module BOAST
     # @option properties [Array<Dimension>] :dimension (or *:dim*) variable is an array rather than a scalar. Dimensions are given in Fortran order (contiguous first).
     # @option properties [Object] :constant (or *:const*) states that the variable is a constant and give its value. For Variable with the *:dimension* property set must be a {ConstArray}
     # @option properties [Boolean] :restrict specifies that the compiler can assume no aliasing to this array.
+    # @option properties [Boolean] :reference specifies that this variable is passed by reference.
     # @option properties [Symbol] :allocate specify that the variable is to be allocated and where. Can only be *:heap* or *:stack* for now.
     # @option properties [Boolean] :local indicates that the variable is to be allocated on the __local space of OpenCL devices or __shared__ space of CUDA devices. In C or FORTRAN this has the same effect as *:allocate* => *:stack*.
     # @option properties [Boolean] :texture for OpenCL and CUDA. In OpenCL also specifies that a sampler has to be generated to access the array variable.
@@ -258,6 +264,7 @@ module BOAST
       @alignment = properties[:align]
       @deferred_shape = properties[:deferred_shape]
       @optional = properties[:optional]
+      @reference = properties[:reference]
       @force_replace_constant = false
       if not properties[:replace_constant].nil? then
         @replace_constant = properties[:replace_constant]
@@ -308,7 +315,7 @@ module BOAST
         s = @constant.to_s + @type.suffix
         return s
       end
-      if @scalar_output and [C, CL, CUDA].include?( lang ) and not decl_module? then
+      if @scalar_output or @reference and [C, CL, CUDA].include?( lang ) and not decl_module? then
         return "(*#{name})"
       end
       return @name
@@ -348,7 +355,7 @@ module BOAST
       if dimension? then
         s += " *" unless (use_vla? and lang != FORTRAN)
       end
-      if not dimension? and ( lang == FORTRAN or @direction == :out or @direction == :inout ) then
+      if not dimension? and ( lang == FORTRAN or @direction == :out or @direction == :inout or @reference ) then
         s += " *"
       end
       s += " #{@name}"
@@ -365,7 +372,7 @@ module BOAST
     def decl_ffi(alloc, lang)
       return :pointer if lang == FORTRAN and not alloc
       return :pointer if dimension?
-      return :pointer if @direction == :out or @direction == :inout and not alloc
+      return :pointer if @direction == :out or @direction == :inout or @reference and not alloc
       return @type.decl_ffi
     end
 
@@ -426,7 +433,7 @@ module BOAST
     end
 
     def __pointer?(device = false)
-      return !!( ( not dimension? and ( @direction == :out or @direction == :inout ) ) or __pointer_array?(device) )
+      return !!( ( not dimension? and ( @direction == :out or @direction == :inout or @reference ) ) or __pointer_array?(device) )
     end
 
     def __restrict?

data/lib/BOAST/Optimization/Optimization.rb

@@ -20,26 +20,64 @@ module BOAST
 
   class OptimizationSpace
     attr_reader :parameters
+    attr_reader :rules
+    attr_reader :checkers
+    HASH_NAME = "options"
 
     def initialize( *parameters )
       if parameters.length == 1 and parameters[0].is_a?(Hash) then
         @parameters = []
         parameters[0].each { |key, value|
-          @parameters.push( OptimizationParameter::new(key, value) )
+          if key == :rules then
+            @rules = [value].flatten
+            format_rules
+          elsif key == :checkers then
+            @checkers = [value].flatten
+          else
+            @parameters.push( OptimizationParameter::new(key, value) )
+          end
         }
       else
         @parameters = parameters
       end
     end
 
+    # Add to the parameters of the rules the name of the hash variable
+    def format_rules
+      regxp = /(?<!#{HASH_NAME}\[):\w+(?!\])/
+      @rules.each{|r|
+        matches = r.scan(regxp)
+        matches = matches.uniq
+        matches.each{ |m|
+          r.gsub!(/(?<!#{HASH_NAME}\[)#{m}(?!\])/, "#{HASH_NAME}[#{m}]")
+        }
+      }
+    end
+
+    # Remove all points that do not meet ALL the rules.
+    def remove_unfeasible (points = [])
+      if @rules then
+        if @checkers
+          @checkers.each { |checker| eval checker }
+        end
+        s = <<EOF
+      points.reject!{ |#{HASH_NAME}|
+        not @rules.all?{ |r| eval r }
+      }
+EOF
+        eval s
+      end
+    end
+
     def to_h
       h = {}
       @parameters.each { |p|
         h[p.name] = p.values
       }
+      h[:rules] = @rules if @rules
+      h[:checkers] = @checkers if @checkers
       return h
     end
-
   end
 
   class Optimizer
@@ -47,6 +85,7 @@ module BOAST
     attr_reader :experiments
     attr_reader :search_space
     attr_reader :log
+    attr_reader :history
 
     def initialize(search_space, options = {} )
       @search_space = search_space
@@ -107,7 +146,7 @@ EOF
         end
 
         def to_s
-          return [opts, fitness].to_s
+          return to_a.to_s
         end
 
       end
@@ -118,13 +157,15 @@ EOF
     def optimize(options={}, &block)
       opts = { :population_size => 20,
                :fitness_goal => 0,
-               :generations_limit => 100 }
+               :generations_limit => 100,
+               :search_space => @search_space }
       opts.update(options)
       opts[:organism] = @organism
       @organism.block = block
       @organism.experiments = 0
       population = Darwinning::Population.new(opts)
       population.evolve!
+      @history = population.history
       @experiments = @organism.experiments
       return population.best_member.to_a
     end
@@ -136,14 +177,18 @@ EOF
     def initialize(search_space, options = {} )
       super
       @randomize = options[:randomize]
+      @checkpoint = options[:checkpoint]
+      @checkpoint_size = options[:checkpoint_size]
+      @seed = options[:seed]
     end
 
     def points
       params2 = @search_space.parameters.dup
       param = params2.shift
+      
       pts = param.values.collect { |val| {param.name => val} }
       if params2.size == 0 then
-        return pts
+        pts4 = pts 
       else
         optim2 = BruteForceOptimizer::new(OptimizationSpace::new(*params2))
         pts3=[]
@@ -152,8 +197,10 @@ EOF
             pts3.push(p1.dup.update(p2))
           }
         }
-        return pts3
+        pts4 = pts3
       end
+      @search_space.remove_unfeasible pts4
+      return pts4
     end
 
     def each(&block)
@@ -169,7 +216,11 @@ EOF
       @log = {}
       best = [nil, Float::INFINITY]
       pts = points
-      pts.shuffle! if @randomize
+      
+      (@seed ? pts.shuffle!(random: Random.new(@seed)) : pts.shuffle!) if @randomize
+
+      pts = pts.slice(@checkpoint,@checkpoint_size) if @checkpoint_size
+
       pts.each { |config|
         @experiments += 1
         metric = block.call(config)

data/lib/BOAST/Runtime/CRuntime.rb

@@ -26,7 +26,7 @@ module BOAST
       @procedure.parameters.each { |param|
         if param.dimension then
           params.push( param.name )
-        elsif param.direction == :out or param.direction == :inout then
+        elsif param.direction == :out or param.direction == :inout or param.reference? then
           params.push( "&"+param.name )
         else
           params.push( param.name )

data/lib/BOAST/Runtime/CompiledRuntime.rb

@@ -220,6 +220,7 @@ EOF
         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]

data/lib/BOAST/Runtime/EnergyProbe.rb

@@ -123,7 +123,7 @@ EOF
 }
 EOF
     end
-    def is_available
+    def is_available?
       [] != Dir.glob( '/sys/class/powercap/intel-rapl:0:0' )
     end
   end
@@ -177,8 +177,13 @@ EOF
 }
 EOF
 		end
-    def is_available
-      [] != ENV['LIBRARY_PATH'].split(':').inject([]){|mem, x| []!=mem ? mem : Dir.glob(x+'/libredfst.so')}
+    def is_available?
+      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 == []
+      return path != []
     end
   end
 
@@ -215,15 +220,20 @@ EOF
 }
 EOF
     end
-    def is_available
-      [] != ENV['LIBRARY_PATH'].split(':').inject([]){|mem, x| []!=mem ? mem : Dir.glob(x+'/libeml.so')}
+    def is_available?
+      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 == []
+      return path != []
     end
   end
-  if PowercapProbe.is_available
+  if PowercapProbe.is_available?
     EnergyProbe = PowercapProbe
-  elsif RedfstProbe.is_available
+  elsif RedfstProbe.is_available?
     EnergyProbe = RedfstProbe
-  elsif EmlProbe.is_available
+  elsif EmlProbe.is_available?
     EnergyProbe = EmlProbe
   else
     EnergyProbe = nil