BOAST 1.3.5 → 2.0.0

data/lib/BOAST/Language/Algorithm.rb

@@ -53,32 +53,12 @@ module BOAST
 
   # Returns the symbol corresponding to the active architecture
   def get_architecture_name
-    case architecture
-    when X86
-      return :X86
-    when ARM
-      return :ARM
-    when MPPA
-      return :MPPA
-    else
-      return nil
-    end
+    return ARCHITECTURES[architecture]
   end
 
   # Returns the symbol corresponding to the active language
   def get_lang_name
-    case lang
-    when C
-      return :C
-    when FORTRAN
-      return :FORTRAN
-    when CL
-      return :CL
-    when CUDA
-      return :CUDA
-    else
-      nil
-    end
+    return LANGUAGES[lang]
   end
 
   @@output = STDOUT
@@ -174,9 +154,9 @@ module BOAST
   # Calls the given object pr method with the optional arguments.
   # @param a a BOAST Expression, ControlStructure or Procedure
   # @param args an optional list of parameters
-  def pr(a, *args)
+  def pr(a, *args, &block)
     pr_annotate(a) if annotate?
-    a.pr(*args)
+    a.pr(*args, &block)
   end
 
   # One of BOAST keywords: declares BOAST Variables and Procedures.

data/lib/BOAST/Language/Architectures.rb

@@ -293,4 +293,9 @@ X86architectures ={"pentium2"=>["MMX"],
    "SSE",
    "MMX"]}
   private_constant :X86architectures
+  ARMarchitectures = {
+    "armv7-a" => ["NEON"],
+    "armv8-a" => ["ASIMD"]
+  }
+  private_constant :ARMarchitectures
 end

data/lib/BOAST/Language/Arithmetic.rb

@@ -2,32 +2,58 @@ module BOAST
 
   module TopLevelExpressions
 
+    # Creates a return Expression
+    # @param [#to_var] value to return
+    # @return [Expression]
     def Return(value)
       return Expression::new("return",nil, value)
     end
 
+    # Creates an Expression using the boolean And Operator
+    # @param [#to_var] a
+    # @param [#to_var] b
+    # @return [Expression]
     def And(a, b)
       return Expression::new(And, a, b)
     end
 
+    # Creates an Expression using the boolean Or Operator
+    # @param [#to_var] a
+    # @param [#to_var] b
+    # @return [Expression]
     def Or(a, b)
       return Expression::new(Or, a, b)
     end
 
+    def Max(a, b)
+      return Expression::new(Max, a, b)
+    end
+
+    def Min(a, b)
+      return Expression::new(Min, a, b)
+    end
+
   end
 
   extend TopLevelExpressions
 
   EXTENDED.push TopLevelExpressions
 
+  # Defines arithmetic operation, mostly using operator overloading.
   module Arithmetic
 
+    # Returns an Exponentiation Expression bewtween self and x
+    # @param [#to_var] x
+    # @return [Expression]
     def **(x)
       return Expression::new(Exponentiation,self,x)
     end
 
+    # Returns an Affectation Expression x into self
+    # @param [#to_var] x
+    # @return [Expression]
     def ===(x)
-      return Expression::new(Affectation,self,x)
+      return Affectation::new(self,x)
     end
 
     def !
@@ -63,7 +89,7 @@ module BOAST
     end
 
     def -(x)
-      return Expression::new(Substraction,self,x)
+      return Expression::new(Subtraction,self,x)
     end
  
     def *(x)
@@ -110,11 +136,18 @@ module BOAST
     end
 
     def components( range )
-      if self.type.vector_length == 1
+      var = self.to_var
+      if var.type.vector_length == 1
         return self
       else
-        existing_set = [*('0'..'9'),*('a'..'z')].first(self.type.vector_length)
-        eval "self.s#{existing_set[range].join("")}"
+        existing_set = [*('0'..'9'),*('a'..'z')].first(var.type.vector_length)
+        if range.kind_of?(Range) then
+          eval "self.s#{existing_set[range].join("")}"
+        elsif range.kind_of?(Array) then
+          eval "self.s#{existing_set.values_at(*range).join("")}"
+        else
+          eval "self.s#{existing_set[range]}"
+        end
       end
     end
 

data/lib/BOAST/Language/BOAST_OpenCL.rb

@@ -13,7 +13,6 @@ module BOAST
 
     def barrier(*locality)
       if lang == CL then
-        loc=""
         if locality.include?(:local) and locality.include?(:global) then
           return FuncCall::new("barrier","CLK_LOCAL_MEM_FENCE | CLK_GLOBAL_MEM_FENCE")
         elsif locality.include?(:local) then
@@ -32,7 +31,7 @@ module BOAST
 
     def get_work_dim
       if lang == CL then
-        return FuncCall::new("get_work_dim", :returns => Int("wd", :signed => false))
+        return FuncCall::new("get_work_dim", :return => Int("wd", :signed => false))
       else
         raise "Unsupported language!"
       end
@@ -40,7 +39,7 @@ module BOAST
   
     def get_global_size(dim)
       if lang == CL then
-        return FuncCall::new("get_global_size", dim, :returns => Sizet)
+        return FuncCall::new("get_global_size", dim, :return => Sizet)
       elsif lang == CUDA then
         d = OCL_CUDA_DIM_ASSOC[dim]
         raise "Unsupported dimension!" if not d
@@ -52,7 +51,7 @@ module BOAST
 
     def get_global_id(dim)
       if lang == CL then
-        return FuncCall::new("get_global_id",dim, :returns => Sizet)
+        return FuncCall::new("get_global_id",dim, :return => Sizet)
       elsif lang == CUDA then
         d = OCL_CUDA_DIM_ASSOC[dim]
         raise "Unsupported dimension!" if not d
@@ -64,7 +63,7 @@ module BOAST
 
     def get_local_size(dim)
       if lang == CL then
-        return FuncCall::new("get_local_size",dim, :returns => Sizet)
+        return FuncCall::new("get_local_size",dim, :return => Sizet)
       elsif lang == CUDA then
         d = OCL_CUDA_DIM_ASSOC[dim]
         raise "Unsupported dimension!" if not d
@@ -76,7 +75,7 @@ module BOAST
 
     def get_local_id(dim)
       if lang == CL then
-        return FuncCall::new("get_local_id",dim, :returns => Sizet)
+        return FuncCall::new("get_local_id",dim, :return => Sizet)
       elsif lang == CUDA then
         d = OCL_CUDA_DIM_ASSOC[dim]
         raise "Unsupported dimension!" if not d
@@ -88,7 +87,7 @@ module BOAST
   
     def get_num_groups(dim)
       if lang == CL then
-        return FuncCall::new("get_num_groups",dim, :returns => Sizet)
+        return FuncCall::new("get_num_groups",dim, :return => Sizet)
       elsif lang == CUDA then
         d = OCL_CUDA_DIM_ASSOC[dim]
         raise "Unsupported dimension!" if not d
@@ -100,7 +99,7 @@ module BOAST
 
     def get_group_id(dim)
       if lang == CL then
-        return FuncCall::new("get_group_id",dim, :returns => Sizet)
+        return FuncCall::new("get_group_id",dim, :return => Sizet)
       elsif lang == CUDA then
         d = OCL_CUDA_DIM_ASSOC[dim]
         raise "Unsupported dimension!" if not d

data/lib/BOAST/Language/Case.rb

@@ -6,6 +6,7 @@ module BOAST
     attr_reader :constants
 
     def initialize(constants = nil, &block)
+      super()
       @constants = constants
       @block = block
     end
@@ -61,11 +62,12 @@ module BOAST
       return self
     end
 
-    def pr(*args)
+    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
@@ -79,7 +81,12 @@ module BOAST
     attr_reader :expression
     attr_reader :case_conditions
 
+    # Creates a new instance of the Caonstruct
+    # @param [#to_s] expression tested Expression/Variable
+    # @param [Hash{#to_s, :default => Proc}] control conditions and associated blocks.
+    # @param [Proc,nil] block if provided, and :default is not defined in control (or nil), will be used as the default block.
     def initialize(expression, control = {}, &block)
+      super()
       @expression = expression
       @case_conditions = []
       default = control.delete(:default)

data/lib/BOAST/Language/Config.rb

@@ -2,13 +2,17 @@ require 'os'
 require 'yaml'
 
 module BOAST
-  FORTRAN = 1
-  C = 2
-  CL = 3
-  CUDA = 4
-  X86 = 1
-  ARM = 2
-  MPPA = 3
+
+  LANGUAGES = ['FORTRAN', 'C', 'CL', 'CUDA']
+  ARCHITECTURES = ['X86', 'ARM', 'MPPA']
+
+  LANGUAGES.each_with_index { |l, i|
+    const_set(l, i)
+  }
+
+  ARCHITECTURES.each_with_index { |a, i|
+    const_set(a, i)
+  }
 
   @@boast_config = {
     :fortran_line_length => 72
@@ -51,6 +55,7 @@ module BOAST
     private_state_accessor :architecture
     private_state_accessor :model
     private_state_accessor :address_size
+    private_state_accessor :default_type
     private_state_accessor :default_int_size
     private_state_accessor :default_real_size
     private_state_accessor :default_align
@@ -79,6 +84,7 @@ module BOAST
   state_accessor :architecture
   state_accessor :model
   state_accessor :address_size
+  state_accessor :default_type
   state_accessor :default_int_size
   state_accessor :default_real_size
   state_accessor :default_align
@@ -127,30 +133,48 @@ module BOAST
   class << self
     alias use_vla_old? use_vla?
     private :use_vla_old?
+    alias set_model_old set_model
+    private :set_model_old
+    alias model_old= model=
+    private :model_old=
   end
 
+  undef_method :use_vla?
   # @return the boolean evaluation of the *use_vla* state. false if lang is CL or CUDA.
   def use_vla?
     return false if [CL,CUDA].include?(lang)
     return use_vla_old?
   end
 
+  undef_method :set_model
   def set_model(val)
-    @@model=val
+    set_model_old(val)
     Intrinsics::generate_conversions
   end
 
+  undef_method :model=
   def model=(val)
-    @@model=val
+    set_model_old(val)
     Intrinsics::generate_conversions
   end
 
   # @private
   def get_default_architecture
-    architecture = const_get(ENV["ARCHITECTURE"]) if ENV["ARCHITECTURE"]
-    architecture = const_get(ENV["ARCH"]) if not architecture and ENV["ARCH"]
+    architecture = nil
+    begin
+      env = nil
+      if ENV["ARCHITECTURE"] then
+        env = ENV["ARCHITECTURE"]
+      elsif ENV["ARCH"] then
+        env = ENV["ARCH"]
+      end
+      raise "Error" if env and not ARCHITECTURES.include?(env)
+      architecture = const_get(env) if env
+    rescue
+      raise "'#{env}' is not a valid value for ARCH or ARCHITECTURE!"
+    end
     return architecture if architecture
-    return ARM if YAML::load( OS.report )["host_cpu"].match("arm")
+    return ARM if YAML::load( OS.report )["host_cpu"].match(/arm|aarch64/)
     return X86
   end
 

data/lib/BOAST/Language/ControlStructure.rb

@@ -21,16 +21,16 @@ module BOAST
 
     class << self
 
+      private
+
       def token_string_generator(name, *args)
-       s = <<EOF
+       return <<EOF
     def #{name}_string(#{args.join(",")})
       return eval get_strings[get_lang][:#{name}]
     end
 EOF
       end
 
-      private :token_string_generator
-
     end
 
     def [](*args)
@@ -38,6 +38,10 @@ EOF
       return self
     end
 
+    def initialize
+      @args = nil
+    end
+
   end
 
 end

data/lib/BOAST/Language/DataTypes.rb

@@ -9,6 +9,10 @@ module BOAST
       child.extend( VarFunctor)
     end
 
+    def vector?
+      return @vector_length
+    end
+
   end
 
   # @!parse module VarFunctors; var_functorize Sizet; end
@@ -259,6 +263,8 @@ module BOAST
 
   end
 
+  default_state_getter :default_type,          Int, '"const_get(#{envs})"'
+
   # @!parse module VarFunctors; var_functorize CStruct; end
   class CStruct < DataType
 

data/lib/BOAST/Language/Expression.rb

@@ -13,6 +13,26 @@ module BOAST
 
     ANNOTATIONS = [:operator, :operand1, :operand2]
 
+    def method_missing(m, *a, &b)
+      var = to_var
+      if var.type.methods.include?(:members) and var.type.members[m.to_s] then
+        return struct_reference(type.members[m.to_s])
+      elsif var.vector? and m.to_s[0] == 's' and lang != CUDA then
+        required_set = m.to_s[1..-1].chars.to_a
+        existing_set = [*('0'..'9'),*('a'..'z')].first(var.type.vector_length)
+        if required_set.length == required_set.uniq.length and (required_set - existing_set).empty? then
+          return var.copy(var.name+"."+m.to_s, :vector_length => m.to_s[1..-1].length) if lang == CL
+          return var.copy("(#{var.name})(#{existing_set.index(required_set[0])+1})", :vector_length => 1) if lang == FORTRAN
+          return var.copy("(#{var.name})[#{existing_set.index(required_set[0])}]", :vector_length => 1) if lang == C
+          return super
+        else
+          return super
+        end
+      else
+        return super
+      end
+    end
+
     attr_reader :operator
     attr_reader :operand1
     attr_reader :operand2
@@ -20,6 +40,10 @@ module BOAST
       @operator = operator
       @operand1 = operand1
       @operand2 = operand2
+      if @operand1.nil? and @operand2.nil?
+        STDERR.puts "#{@operand1} #{@operand2}"
+        raise "Expression on no operand!"
+      end
     end
 
     def to_s_base(op1, op2, oper, return_type = nil)
@@ -59,8 +83,8 @@ module BOAST
         res_exp = to_s_base(op1, @operand2, @operator)
         return op1.copy(res_exp, :const => nil, :constant => nil, :direction => nil, :dir => nil, :align => nil)
       else
-        STDERR.puts "#{@operand1} #{@operand2}"
-        raise "Expression on no operand!"
+        res_exp = to_s_base(@operand1, @operand2, @operator)
+        return Variable::new(res_exp, get_default_type)
       end
     end