BOAST 0.99996 → 0.99997

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 40c21d4b9f3af7ba3e0a34a8a55b9a7d65329f8f
-  data.tar.gz: dd8c7914a2b7918295453dbeffd172a505014cf6
+  metadata.gz: bb89f1443e6a90d1e3de87c5d9d6a23987b4c18a
+  data.tar.gz: c305d01f65fbdf595bb9a381589cd7220c67e5eb
 SHA512:
-  metadata.gz: 2bbe1a51a60e2cd46ceaa611e45d51e294d893c3b2d528fd586fdbd89bdd1ba0b8a0c3189569989a0c2e5a532b16a71e02b3ce5835a44b0b238214d8cf9e4340
-  data.tar.gz: f661fa69d0309e6c6b2f294925c08b1c6ddf9f854f745d1b1bb8d1f79d6519d105b8f854eb8514c6f75e96bffbd181ff71ee6fd2028ef1f05f6a8f4bcfc126ce
+  metadata.gz: a3a43dac0e6441cb2b1cc646bb40953974f861d5c8fb2e199ea60c517964c08eca4e20aba5a4831932b246cb1164633ca8d53196e3b77413bac0aa6eca7176d8
+  data.tar.gz: 94959453ffdf64b5e73429771eaaf1cc809369fd214be89668b51a27ae896554cdc053271af1877aa7ed4b42d5be1b4e3b116b9d5c9a6684f9467bffa7bfef89

data/BOAST.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'BOAST'
-  s.version = "0.99996"
+  s.version = "0.99997"
   s.author = "Brice Videau"
   s.email = "brice.videau@imag.fr"
   s.homepage = "https://forge.imag.fr/projects/boast/"
@@ -34,6 +34,7 @@ Gem::Specification.new do |s|
                 lib/BOAST/State.rb
                 lib/BOAST/Optimization.rb
                 lib/BOAST/OpenMP.rb
+                lib/BOAST/Slice.rb
               )
   s.has_rdoc = true
   s.license = 'BSD'

data/lib/BOAST/Algorithm.rb

@@ -20,6 +20,8 @@ module BOAST
     private_boolean_state_accessor :default_int_signed
     private_boolean_state_accessor :chain_code
     private_boolean_state_accessor :debug
+    private_boolean_state_accessor :use_vla
+    private_boolean_state_accessor :decl_module
 
     private
     def push_env(*args)
@@ -53,6 +55,8 @@ module BOAST
   boolean_state_accessor :default_int_signed
   boolean_state_accessor :chain_code
   boolean_state_accessor :debug
+  boolean_state_accessor :use_vla
+  boolean_state_accessor :decl_module
 
   module_function
 
@@ -68,6 +72,12 @@ module BOAST
     return debug
   end
 
+  def get_default_use_vla
+    use_vla = false
+    use_vla = ENV["USE_VLA"] if ENV["USE_VLA"]
+    return use_vla
+  end
+
   @@output = STDOUT
   @@lang = get_default_lang
   @@replace_constants = true
@@ -80,6 +90,8 @@ module BOAST
   @@chain_code = false
   @@architecture = X86
   @@debug = get_default_debug
+  @@use_vla = get_default_use_vla
+  @@decl_module = false
 
   @@env = Hash::new{|h, k| h[k] = []}
 

data/lib/BOAST/CKernel.rb

@@ -662,12 +662,14 @@ EOF
     end
 
     def decl_module_params(module_file)
+      set_decl_module(true)
       @procedure.parameters.each { |param| 
         param_copy = param.copy
         param_copy.constant = nil
         param_copy.direction = nil
         param_copy.decl
       }
+      set_decl_module(false)
       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"

data/lib/BOAST/Case.rb

@@ -25,28 +25,24 @@ module BOAST
       end
     end
 
-    @@c_strings = {
-      :switch => '"switch (#{expr}) {"',
-      :case => '"case #{constants.join(" : case")} :"',
-      :default => '"default :"',
-      :break => '"break;"',
-      :end => '"}"'
-    }
+    def get_c_strings
+      return { :switch => '"switch (#{expr}) {"',
+               :case => '"case #{constants.join(" : case")} :"',
+               :default => '"default :"',
+               :break => '"break;"',
+               :end => '"}"' }
+    end
 
-    @@f_strings = {
-      :switch => '"select case (#{expr})"',
-      :case => '"case (#{constants.join(" : ")})"',
-      :default => '"case default"',
-      :break => 'nil',
-      :end => '"end select"'
-    }
+    def get_fortran_strings
+      return { :switch => '"select case (#{expr})"',
+               :case => '"case (#{constants.join(" : ")})"',
+               :default => '"case default"',
+               :break => 'nil',
+               :end => '"end select"' }
+    end
 
-    @@strings = {
-      C => @@c_strings,
-      CL => @@c_strings,
-      CUDA => @@c_strings,
-      FORTRAN => @@f_strings
-    }
+    alias get_cl_strings get_c_strings
+    alias get_cuda_strings get_c_strings
 
     eval token_string_generator( * %w{switch expr})
     eval token_string_generator( * %w{case constants})

data/lib/BOAST/ControlStructure.rb

@@ -8,10 +8,17 @@ module BOAST
       child.extend Functor
     end
 
+    def get_strings
+      return { C => get_c_strings,
+               CL => get_cl_strings,
+               CUDA => get_cuda_strings,
+               FORTRAN => get_fortran_strings }
+    end
+
     def self.token_string_generator(name, *args)
        s = <<EOF
     def #{name}_string(#{args.join(",")})
-      return eval @@strings[get_lang][:#{name}] 
+      return eval get_strings[get_lang][:#{name}] 
     end
 EOF
     end

data/lib/BOAST/For.rb

@@ -1,7 +1,6 @@
 module BOAST
 
   class For < ControlStructure
-    include OpenMP::Pragma
 
     attr_reader :iterator
     attr_reader :begin
@@ -18,10 +17,12 @@ module BOAST
       @operator = "<="
       @block = block
       @openmp = default_options[:openmp]
-      if @openmp and @openmp.kind_of?(Hash) then
-        @openmp_clauses = @openmp
-      else
-        @openmp_clauses = {}
+      if @openmp then
+        if @openmp.kind_of?(Hash) then
+          @openmp = OpenMP::For(@openmp)
+        else
+          @openmp = OpenMP::For({})
+        end
       end
       begin
         push_env( :replace_constants => true )
@@ -40,31 +41,21 @@ module BOAST
       end
     end
 
-    @@c_strings = {
-      :for => '"for (#{i} = #{b}; #{i} #{o} #{e}; #{i} += #{s}) {"',
-      :end => '"}"',
-      :openmp_for => '"#pragma omp for #{c}"',
-      :openmp_end => '""'
-    }
+    def get_c_strings
+      return { :for => '"for (#{i} = #{b}; #{i} #{o} #{e}; #{i} += #{s}) {"',
+               :end => '"}"' }
+    end
 
-    @@f_strings = {
-      :for => '"do #{i} = #{b}, #{e}, #{s}"',
-      :end => '"end do"',
-      :openmp_for => '"!$omp do #{c}"',
-      :openmp_end => '"!$omp end do #{c}"'
-    }
+    def get_fortran_strings
+      return { :for => '"do #{i} = #{b}, #{e}, #{s}"',
+               :end => '"end do"' }
+    end
 
-    @@strings = {
-      C => @@c_strings,
-      CL => @@c_strings,
-      CUDA => @@c_strings,
-      FORTRAN => @@f_strings
-    }
+    alias get_cl_strings get_c_strings
+    alias get_cuda_strings get_c_strings
 
     eval token_string_generator( * %w{for i b e s o})
     eval token_string_generator( * %w{end})
-    eval token_string_generator( * %w{openmp_for c})
-    eval token_string_generator( * %w{openmp_end c})
 
     def to_s
       s = for_string(@iterator, @begin, @end, @step, @operator)
@@ -115,7 +106,7 @@ module BOAST
     end
 
     def open
-      output.puts openmp_for_string(openmp_clauses_to_s) if @openmp
+      @openmp.open if @openmp
       s=""
       s += indent
       s += to_s
@@ -139,7 +130,8 @@ module BOAST
       s += indent
       s += end_string
       output.puts s
-      output.puts openmp_end_string(openmp_end_clauses_to_s) if @openmp and openmp_end_string(openmp_end_clauses_to_s) != ""
+      @openmp.close if @openmp
+      return self
     end
 
   end

data/lib/BOAST/Functors.rb

@@ -28,7 +28,7 @@ EOF
   module Functor
 
     def self.extended(mod)
-      BOAST::functorize(mod)
+      eval "#{mod.name.split('::')[-2]}::functorize(mod)"
     end
 
   end
@@ -36,7 +36,7 @@ EOF
   module VarFunctor
 
     def self.extended(mod)
-      BOAST::var_functorize(mod)
+      eval "#{mod.name.split('::')[-2]}::var_functorize(mod)"
     end
 
   end

data/lib/BOAST/If.rb

@@ -26,26 +26,22 @@ module BOAST
       end
     end
 
-    @@c_strings = {
-      :if => '"if (#{cond}) {"',
-      :else_if => '"} else if (#{cond}) {"',
-      :else => '"} else {"',
-      :end => '"}"'
-    }
+    def get_c_strings
+      return { :if => '"if (#{cond}) {"',
+               :else_if => '"} else if (#{cond}) {"',
+               :else => '"} else {"',
+               :end => '"}"' }
+    end
 
-    @@f_strings = {
-      :if => '"if (#{cond}) then"',
-      :elsif => '"else if (#{cond}) then"',
-      :else => '"else"',
-      :end => '"end if"'
-    }
+    def get_fortran_strings
+      return { :if => '"if (#{cond}) then"',
+               :elsif => '"else if (#{cond}) then"',
+               :else => '"else"',
+               :end => '"end if"' }
+    end
 
-    @@strings = {
-      C => @@c_strings,
-      CL => @@c_strings,
-      CUDA => @@c_strings,
-      FORTRAN => @@f_strings
-    }
+    alias get_cl_strings get_c_strings
+    alias get_cuda_strings get_c_strings
 
     eval token_string_generator( * %w{if cond} )
     eval token_string_generator( * %w{elsif cond} )

data/lib/BOAST/Index.rb

@@ -23,11 +23,7 @@ module BOAST
           (0...dims.length).each { |indx|
             dim = dims[indx]
             s = "#{indxs[indx]}"
-            if dim.val2 then
-              s += " - (#{dim.val1})"
-            elsif 0 != get_array_start then
-              s += " - (#{get_array_start})"
-            end
+            s += " - (#{dim.start})" unless 0.equal?(dim.start)
             ind = eval(s)
             ind = ind.to_i
             const = const[ind]
@@ -92,6 +88,18 @@ module BOAST
       return s
     end
 
+    def to_s_use_vla
+      indxs = @indexes.reverse
+      dims = @source.dimension.reverse
+      t = (0...dims.length).collect { |indx|
+        s = "#{indxs[indx]}"
+        dim = dims[indx]
+        s += " - (#{dim.start})" unless 0.equal?(dim.start)
+        s
+      }
+      return t.join("][")
+    end
+
     def to_s_c_reversed
       indxs = @indexes.reverse
       dims = @source.dimension.reverse
@@ -100,16 +108,10 @@ module BOAST
         s = ""
         dim = dims[indx]
         s += "#{indxs[indx]}"
-        if dim.val2 then
-          s += " - (#{dim.val1})"
-        elsif 0 != get_array_start then
-          s += " - (#{get_array_start})"
-        end
+        s += " - (#{dim.start})" unless 0.equal?(dim.start)
         if ss then
           if dim.size then
             s += " + (#{dim.size}) * "
-          elsif dim.val2 then
-            s += " + (#{dim.val2} - (#{dim.val1}) + 1) * "
           else
             raise "Unkwown dimension size!"
           end
@@ -122,7 +124,11 @@ module BOAST
 
     def to_s_c
       return to_s_texture if @source.texture
-      sub = to_s_c_reversed
+      if use_vla? then
+        sub = to_s_use_vla
+      else
+        sub = to_s_c_reversed
+      end
       s = "#{@source}[" + sub + "]"
       return s
     end

data/lib/BOAST/OpenMP.rb

@@ -16,66 +16,101 @@ module BOAST
         return s
       end
 
-      def openmp_clauses_to_s
+      # Registers an openmp clause, arg_type can be :none, :option, :option_list, :simple, :list, :multilist
+      def self.register_clause( name, arg_type )
+        s = <<EOF
+      def openmp_clause_#{name}(c)
+EOF
+        case arg_type
+        when :none
+          s += <<EOF
+        return " #{name}"
+EOF
+        when :option
+          s += <<EOF
+        return " \#{c}"
+EOF
+        when :option_list
+          s += <<EOF
+        return " (\#{[c].flatten.join(", ")})"
+EOF
+        when :simple
+          s += <<EOF
+        return " #{name}(\#{c})"
+EOF
+        when :list
+s += <<EOF
+        return " #{name}(\#{[c].flatten.join(", ")})"
+EOF
+        when :multilist
+s += <<EOF
         s = ""
-        if @openmp_clauses[:if] then
-          s += " if(#{@openmp_clauses[:if]})"
-        end
-        if @openmp_clauses[:num_threads] then
-          s += " num_threads(#{@openmp_clauses[:num_threads]})"
-        end
-        if @openmp_clauses[:default] then
-          s += " default(#{@openmp_clauses[:default]})"
-        end
-        if @openmp_clauses[:private] then
-          s += " private(#{[@openmp_clauses[:private]].flatten.join(", ")})"
-        end
-        if @openmp_clauses[:firstprivate] then
-          s += " firstprivate(#{[@openmp_clauses[:firstprivate]].flatten.join(", ")})"
-        end
-        if @openmp_clauses[:lastprivate] then
-          s += " lastprivate(#{[@openmp_clauses[:lastprivate]].flatten.join(", ")})"
+        c.each { |id, list|
+          s += " #{name}(\#{id}: \#{[list].flatten.join(", ")})"
+        }
+        return s
+EOF
+        else
+          raise "Unknown argument type!"
         end
+        s += <<EOF
+      end
+EOF
+        eval s
+      end
+
+      register_clause(:nowait,       :none)
+      register_clause(:ordered,      :none)
+      register_clause(:untied,       :none)
+      register_clause(:mergeable,    :none)
+      register_clause(:inbranch,     :none)
+      register_clause(:notinbranch,  :none)
+      register_clause(:seq_cst,      :none)
+      register_clause(:name,         :option)
+      register_clause(:flush_list,   :option_list)
+      register_clause(:threadprivate_list,   :option_list)
+      register_clause(:if,           :simple)
+      register_clause(:num_threads,  :simple)
+      register_clause(:default,      :simple)
+      register_clause(:collapse,     :simple)
+      register_clause(:safelen,      :simple)
+      register_clause(:simdlen,      :simple)
+      register_clause(:device,       :simple)
+      register_clause(:private,      :list)
+      register_clause(:shared,       :list)
+      register_clause(:firstprivate, :list)
+      register_clause(:lastprivate,  :list)
+      register_clause(:copyprivate,  :list)
+      register_clause(:copyin,       :list)
+      register_clause(:schedule,     :list)
+      register_clause(:linear,       :list)
+      register_clause(:aligned,      :list)
+      register_clause(:uniform,      :list)
+      register_clause(:to,           :list)
+      register_clause(:from,         :list)
+      register_clause(:reduction,    :multilist)
+      register_clause(:depend,       :multilist)
+      register_clause(:map,          :multilist)
+
+      def openmp_open_clauses_to_s
+        s = ""
+        get_open_clauses.each { |c|
+          s += self.send( "openmp_clause_#{c}", @openmp_clauses[c] ) if @openmp_clauses[c]
+        }
         if lang == C then
-          if @openmp_clauses[:copyprivate] then
-            s += " copyprivate(#{[@openmp_clauses[:copyprivate]].flatten.join(", ")})"
-          end
-          if @openmp_clauses[:nowait] then
-            s += " nowait"
-          end
-        end
-        if @openmp_clauses[:shared] then
-          s += " shared(#{[@openmp_clauses[:shared]].flatten.join(", ")})"
-        end
-        if @openmp_clauses[:copyin] then
-          s += " copyin(#{[@openmp_clauses[:copyin]].flatten.join(", ")})"
-        end
-        if @openmp_clauses[:reduction] then
-          options[:reduction].each { |identifier, list|
-            s += " reduction(#{identifier}: #{list.join(", ")})"
+          get_end_clauses.each { |c|
+            s += self.send( c, @openmp_clauses[c] ) if @openmp_clauses[c]
           }
         end
-        if @openmp_clauses[:schedule] then
-          s += " schedule(#{@openmp_clauses[:schedule].join(", ")})"
-        end
-        if @openmp_clauses[:collapse] then
-          s += " collapse(#{@openmp_clauses[:collapse]})"
-        end
-        if @openmp_clauses[:ordered] then
-          s += " ordered"
-        end
         return s
       end
 
       def openmp_end_clauses_to_s
         s = ""
         if lang == FORTRAN then
-          if @openmp_clauses[:copyprivate] then
-            s += " copyprivate(#{[@openmp_clauses[:copyprivate]].flatten.join(", ")})"
-          end
-          if @openmp_clauses[:nowait] then
-            s += " nowait"
-          end
+          get_end_clauses.each { |c|
+            s += self.send( c, @openmp_clauses[c] ) if @openmp_clauses[c]
+          }
         end
         return s
       end
@@ -94,76 +129,30 @@ module BOAST
 EOF
       eval s
     end
-  
-    def var_functorize(klass)
-      name = klass.name.split('::').last
-      s = <<EOF
-    def #{name}(*args,&block)
-       Variable::new(args[0],#{name},*args[1..-1], &block)
-    end
-
-    module_function :#{name}
-EOF
-      eval s
-    end
-
-    module Functor
-
-      def self.extended(mod)
-        BOAST::OpenMP::functorize(mod)
-      end
-
-    end
-
-    class ControlStructure
-      include PrivateStateAccessor
-      include Inspectable
+ 
+    class OpenMPControlStructure < ControlStructure
       include OpenMP::Pragma
 
-      def self.inherited(child)
-        child.extend Functor
-      end
-
-      def self.token_string_generator(name, *args)
-        s = <<EOF
-      def #{name}_string(#{args.join(",")})
-        return eval @@strings[get_lang][:#{name}] 
-      end
-EOF
+      def get_strings
+        return { C => get_c_strings,
+                 FORTRAN => get_fortran_strings }
       end
 
-    end
-
-    class Parallel < ControlStructure
-
       def initialize(options = {}, &block)
         @openmp_clauses = options
         @block = block
       end
-      @@c_strings = {
-        :parallel => '"#pragma omp parallel #{c}\n{"',
-        :end => '"}"',
-      }
-
-      @@f_strings = {
-        :parallel => '"!$omp parallel #{c}"',
-        :end => '"!$omp end parallel #{c}"',
-      }
 
-      @@strings = {
-        C => @@c_strings,
-        FORTRAN => @@f_strings
-      }
-
-      eval token_string_generator( * %w{parallel c})
+      eval token_string_generator( * %w{begin c})
       eval token_string_generator( * %w{end c})
 
       def to_s
-        return parallel_string(openmp_clauses_to_s)
+        return begin_string(openmp_open_clauses_to_s)
       end
 
       def open
         output.puts to_s
+        return self
       end
 
       def pr(*args)
@@ -177,10 +166,285 @@ EOF
 
       def close
         output.puts end_string(openmp_end_clauses_to_s) 
+        return self
+      end
+     
+    end
+
+    def self.register_openmp_construct( name, c_name, open_clauses, end_clauses = [], options = {} )
+      fortran_name = c_name
+      fortran_name = options[:fortran_name] if options[:fortran_name]
+      s = <<EOF
+    class #{name} < OpenMPControlStructure
+
+      def self.name
+        return "#{name}"
+      end
+
+      def self.c_name
+        return "#{c_name}"
+      end
+
+      def self.fortran_name
+        return "#{fortran_name}"
+      end
+
+      def self.block
+        return #{options[:block] ? "true" : "false"}
+      end
+
+      def get_c_strings
+        return { :begin => '"#pragma omp #{c_name} #{ open_clauses.length + end_clauses.length > 0 ? "\#{c}" : "" }#{ options[:block] ? "\\n{" : "" }"',
+EOF
+      if options[:c_end] then
+        s += <<EOF
+                 :end => '"#pragma omp end #{c_name}"' }
+EOF
+      else
+        s += <<EOF
+                 :end => '"#{ options[:block] ? "}" : "" }"' }
+EOF
       end
+        s += <<EOF
+      end
+
+      def get_fortran_strings
+        return { :begin => '"!$omp #{fortran_name}#{ open_clauses.length > 0 ? " \#{c}" : "" }#{ options[:fortran_block] ? "(" : "" }"',
+EOF
+      if options[:fortran_no_end] then
+        s += <<EOF
+                 :end => '"#{ options[:fortran_block] ? ")" : "" }"' }
+EOF
+      else
+        s += <<EOF
+                 :end => '"!$omp end #{fortran_name} #{ end_clauses.length > 0 ? "\#{c}" : "" }"' }
+EOF
+      end
+        s += <<EOF
+      end
+
+      def self.get_open_clauses
+        return [ #{open_clauses.collect { |c| ":#{c}" }.join(",\n                 ")} ]
+      end
+
+      def self.get_end_clauses
+        return [ #{end_clauses.collect { |c| ":#{c}" }.join(",\n                 ")} ]
+      end
+
+      def get_open_clauses
+        return #{name}.get_open_clauses
+      end
+
+      def get_end_clauses
+        return #{name}.get_end_clauses
+      end
+
+    end
+EOF
+      eval s
+    end
 
+    def self.register_openmp_compound_construct( c1, c2, options = {} )
+      register_openmp_construct( c1.name+c2.name, "#{c1.c_name} #{c2.c_name}",
+                                                  (c1.get_open_clauses + c2.get_open_clauses).uniq,
+                                                  options[:no_end_clauses] ? [] : (c1.get_end_clauses + c2.get_end_clauses).uniq,
+                                                  :fortran_name => "#{c1.fortran_name} #{c2.fortran_name}",
+                                                  :block => options[:block] )
     end
 
+    register_openmp_construct( :Parallel, "parallel",
+                                          [ :if,
+                                            :num_threads,
+                                            :default,
+                                            :private,
+                                            :firstprivate,
+                                            :shared,
+                                            :copyin,
+                                            :reduction,
+                                            :proc_bind ],
+                                          [],
+                                          :block => true )
+
+    register_openmp_construct( :For, "for",
+                                     [ :private,
+                                       :firstprivate,
+                                       :lastprivate,
+                                       :reduction,
+                                       :schedule,
+                                       :collapse,
+                                       :ordered ],
+                                     [ :nowait ],
+                                     :fortran_name => "do" )
+
+    register_openmp_construct( :Sections, "sections",
+                                          [ :private,
+                                            :firstprivate,
+                                            :lastprivate,
+                                            :reduction ],
+                                          [ :nowait ],
+                                          :block => true )
+
+    register_openmp_construct( :Section, "section", [], [],
+                                         :block => true,
+                                         :fortran_no_end => true )
+
+    register_openmp_construct( :Single, "single",
+                                        [ :private,
+                                          :firstprivate ],
+                                        [ :copyprivate,
+                                          :nowait ],
+                                        :block => true )
+
+    register_openmp_construct( :Simd, "simd",
+                                      [ :safelen,
+                                        :linear,
+                                        :aligned,
+                                        :private,
+                                        :lastprivate,
+                                        :reduction,
+                                        :collapse ] )
+
+    register_openmp_construct( :DeclareSimd, "declare simd",
+                                             [ :simdlen,
+                                               :linear,
+                                               :aligned,
+                                               :uniform,
+                                               :inbranch,
+                                               :notinbranch ] )
+
+    register_openmp_compound_construct( For, Simd )
+
+    register_openmp_construct( :TargetData, "target data",
+                                            [ :device,
+                                              :map,
+                                              :if ],
+                                            [],
+                                            :block => true )
+
+    register_openmp_construct( :Target, "target",
+                                        [ :device,
+                                          :map,
+                                          :if ],
+                                        [],
+                                        :block => true )
+
+    register_openmp_construct( :TargetUpdate, "target update",
+                                              [ :to,
+                                                :from,
+                                                :device,
+                                                :if ],
+                                              [],
+                                              :fortran_no_end => true )
+
+    register_openmp_construct( :DeclareTarget, "declare target",
+                                               [],
+                                               [],
+                                               :c_end => true,
+                                               :fortran_no_end => true,
+                                               :fortran_block => true )
+
+    register_openmp_construct( :Teams, "teams",
+                                       [ :num_teams,
+                                         :thread_limit,
+                                         :default,
+                                         :private,
+                                         :firstprivate,
+                                         :shared,
+                                         :reduction ],
+                                       [],
+                                       :block => true )
+
+    register_openmp_construct( :Distribute, "distribute",
+                                            [ :private,
+                                              :firstprivate,
+                                              :collapse,
+                                              :dist_schedule ] )
+
+    register_openmp_compound_construct( Distribute, Simd )
+
+    register_openmp_compound_construct( Parallel, For, :no_end_clauses => true )
+
+    register_openmp_compound_construct( Distribute, ParallelFor )
+
+    register_openmp_compound_construct( Parallel, ForSimd, :no_end_clauses => true )
+
+    register_openmp_compound_construct( Distribute, ParallelForSimd )
+
+    register_openmp_compound_construct( Parallel, Sections, :no_end_clauses => true, :block => true )
+
+    register_openmp_compound_construct( Target, Teams, :block => true )
+
+    register_openmp_compound_construct( Teams, Distribute )
+
+    register_openmp_compound_construct( Teams, DistributeSimd )
+
+    register_openmp_compound_construct( Target, TeamsDistribute )
+
+    register_openmp_compound_construct( Target, TeamsDistributeSimd )
+
+    register_openmp_compound_construct( Teams, DistributeParallelFor )
+
+    register_openmp_compound_construct( Target, TeamsDistributeParallelFor )
+
+    register_openmp_compound_construct( Teams, DistributeParallelForSimd )
+
+    register_openmp_compound_construct( Target, TeamsDistributeParallelForSimd )
+
+    register_openmp_construct( :Task, "task",
+                                      [ :if,
+                                        :final,
+                                        :untied,
+                                        :default,
+                                        :mergeable,
+                                        :private,
+                                        :firstprivate,
+                                        :shared,
+                                        :depend ],
+                                      [],
+                                      :block => true )
+
+    register_openmp_construct( :Taskyield, "taskyield", [], [], :fortran_no_end => true )
+
+    register_openmp_construct( :Master, "master", [], [], :block => true )
+
+    register_openmp_construct( :Critical, "critical", [:name], [:name], :block => true )
+
+    register_openmp_construct( :Barrier, "barrier", [], [], :fortran_no_end => true )
+
+    register_openmp_construct( :Taskwait, "taskwait", [], [], :fortran_no_end => true )
+
+    register_openmp_construct( :Taskgroup, "taskgroup", [], [], :block => true )
+
+    register_openmp_construct( :AtomicRead, "atomic read", [:seq_cst], [] )
+
+    register_openmp_construct( :AtomicWrite, "atomic write", [:seq_cst], [] )
+
+    register_openmp_construct( :AtomicUpdate, "atomic update", [:seq_cst], [] )
+
+    register_openmp_construct( :AtomicCapture, "atomic capture", [:seq_cst], [], :block => true )
+
+    register_openmp_construct( :Flush, "flush", [:flush_list], [], :fortran_no_end => true )
+
+    register_openmp_construct( :Ordered, "ordered", [], [], :block => true )
+
+    register_openmp_construct( :CancelParallel, "cancel parallel", [:if], [], :fortran_no_end => true )
+
+    register_openmp_construct( :CancelSections, "cancel sections", [:if], [], :fortran_no_end => true )
+
+    register_openmp_construct( :CancelFor, "cancel for", [:if], [], :fortran_no_end => true )
+
+    register_openmp_construct( :CancelTaskgroup, "cancel taskgroup", [:if], [], :fortran_no_end => true )
+
+    register_openmp_construct( :CancellationPointParallel, "cancellation point parallel", [], [], :fortran_no_end => true )
+
+    register_openmp_construct( :CancellationPointSections, "cancellation point sections", [], [], :fortran_no_end => true )
+
+    register_openmp_construct( :CancellationPointFor, "cancellation point for", [], [], :fortran_no_end => true )
+
+    register_openmp_construct( :CancellationPointTaskgroup, "cancellation point taskgroup", [], [], :fortran_no_end => true )
+
+    register_openmp_construct( :Threadprivate, "threadprivate", [:threadprivate_list], [], :fortran_no_end => true )
+
   end
 
 end

data/lib/BOAST/Procedure.rb

@@ -123,7 +123,9 @@ module BOAST
       s = ""
       if lang == CL then
         if @properties[:local] then
-          s += "static "
+          s += "#if __OPENCL_C_VERSION__ && __OPENCL_C_VERSION__ >= 120\n"
+          s += "static\n"
+          s += "#endif\n"
         else
           s += "__kernel "
           wgs = @properties[:reqd_work_group_size]

data/lib/BOAST/Slice.rb

@@ -0,0 +1,94 @@
+module BOAST
+
+  class Slice
+    include PrivateStateAccessor
+    include Inspectable
+    attr_reader :source
+    attr_reader :slices
+
+    def initialize(source, *slices)
+      raise "Cannot slice a non array Variable!" if not source.dimension?
+      raise "Invalid slice!" if slices.length != source.dimension.length
+      @source = source
+      @slices = slices
+    end
+
+    def to_s_c
+      s = "#{@source}["
+      dims = @source.dimension.reverse
+      slices = @slices.reverse
+      slices_to_c = []
+      slices.each_index { |indx|
+        slice = slices[indx]
+        if slice.kind_of?(Array) then
+          if slice.length == 0 then
+            slices_to_c.push(":")
+          elsif slice.length == 1 then
+            slices_to_c.push("#{Expression::new(Substraction, slice[0], dims[indx].start)}")
+          else
+            start, finish, step = slice
+            start_c = Expression::new(Substraction, start, dims[indx].start)
+            length = Expression::new(Substraction, finish, start) + 1
+            slices_to_c.push("#{start_c}:#{length}")
+          end
+        elsif slice.kind_of?(Range) then
+          start = slice.first
+          finish = slice.last
+          start_c = Expression::new(Substraction, start, dims[indx].start)
+          length = Expression::new(Substraction, finish, start)
+          length = length + 1 unless slice.exclude_end?
+          slices_to_c.push("#{start_c}:#{length}")
+        elsif slice then
+          slices_to_c.push("#{Expression::new(Substraction, slice, dims[indx].start)}")
+        else
+          slices_to_c.push(":")
+        end
+      }
+      return s + slices_to_c.join("][") + "]"
+    end
+
+    def to_s_fortran
+      slices_to_fortran = @slices.collect { |slice|
+        if slice then
+          if slice.kind_of?(Range) then
+            "#{slice.first}:#{slice.last}#{slice.exclude_end? ? " - 1" : "" }"
+          else
+            sl = [slice].flatten
+            if sl.length > 0 then
+              sl.join(":")
+            else
+              ":"
+            end
+          end
+        else
+          ":"
+        end
+      }
+      return "#{source}(#{slices_to_fortran.join(",")})"
+    end
+
+    def to_s
+      return to_s_fortran if lang == FORTRAN
+      return to_s_c if [C, CL, CUDA].include?( lang )
+    end
+
+    def pr
+      s=""
+      s += indent
+      s += to_s
+      s += ";" if [C, CL, CUDA].include?( lang )
+      output.puts s
+      return self
+    end
+
+  end
+
+  class Variable
+
+    def slice(*slices)
+      Slice::new(self, *slices)
+    end
+
+  end
+
+end

data/lib/BOAST/Variable.rb

@@ -30,6 +30,33 @@ module BOAST
         return @size
       end 
     end
+
+    def start
+      if @val2 then
+        return @val1
+      else
+        return get_array_start
+      end
+    end
+
+    def finish
+      if @val2 then
+        return @val2
+      elsif @size
+        if 0.equal?(get_array_start) then
+          if 1.equal?(get_array_start) then
+            return Expression::new(Addition, @size, get_array_start) - 1
+          else
+            return @size
+          end
+        else
+          return Expression::new(Substraction, @size, 1)
+        end
+      else
+        return nil
+      end
+    end
+
   end
 
   class ConstArray < Array
@@ -242,12 +269,24 @@ module BOAST
       s += "const " if constant? or @direction == :in
       s += @type.decl
       if dimension? then
-        s += " *"
+        s += " *" unless use_vla?
       end
       if not dimension? and ( lang == FORTRAN or @direction == :out or @direction == :inout ) then
         s += " *"
       end
       s += " #{@name}"
+      if dimension? and use_vla? then
+        s += "["
+        s += @dimension.reverse.collect { |d|
+          dim = d.to_s
+          if dim then
+            dim.to_s
+          else
+            ""
+          end
+        }.join("][")
+        s += "]"
+      end
       return s
     end
 
@@ -264,28 +303,41 @@ module BOAST
       s += "__local " if local? and lang == CL
       s += "__shared__ " if local? and not device and lang == CUDA
       s += @type.decl
-      if dimension? and not constant? and not allocate? and (not local? or (local? and device)) then
-        s += " *"
-        if restrict? then
-          if lang == CL
-            s += " restrict"
+      if use_vla? and dimension? and not decl_module? then
+        s += " #{@name}["
+        s += @dimension.reverse.collect { |d|
+          dim = d.to_s
+          if dim then
+            dim.to_s
           else
-            s += " __restrict__"
+            ""
+          end
+        }.join("][")
+        s += "]"
+      else
+        if dimension? and not constant? and not allocate? and (not local? or (local? and device)) then
+          s += " *"
+          if restrict? and not decl_module? then
+            if lang == CL
+              s += " restrict"
+            else
+              s += " __restrict__" unless use_vla?
+            end
           end
         end
+        if not dimension? and ( @direction == :out or @direction == :inout ) then
+          s += " *"
+        end
+        s += " #{@name}"
+        if dimension? and constant? then
+          s += "[]"
+        end
+        if dimension? and ((local? and not device) or (allocate? and not constant?)) then
+          s +="[("
+          s += @dimension.collect{ |d| d.to_s }.reverse.join(")*(")
+          s +=")]"
+        end 
       end
-      if not dimension? and ( @direction == :out or @direction == :inout ) then
-        s += " *"
-      end
-      s += " #{@name}"
-      if dimension? and constant? then
-        s += "[]"
-      end
-      if dimension? and ((local? and not device) or (allocate? and not constant?)) then
-         s +="[("
-         s += @dimension.collect{ |d| d.to_s }.reverse.join(")*(")
-         s +=")]"
-      end 
       s += " = #{@constant}" if constant?
       return s
     end

data/lib/BOAST/While.rb

@@ -9,22 +9,18 @@ module BOAST
       @block = block
     end
 
-    @@c_strings = {
-      :while => '"while (#{cond}) {"',
-      :end => '"}"'
-    }
+    def get_c_strings
+      return { :while => '"while (#{cond}) {"',
+               :end => '"}"' }
+    end
 
-    @@f_strings = {
-      :while => '"do while (#{cond})"',
-      :end => '"end do"'
-    }
+    def get_fortran_strings
+      return { :while => '"do while (#{cond})"',
+               :end => '"end do"' }
+    end
 
-    @@strings = {
-      C => @@c_strings,
-      CL => @@c_strings,
-      CUDA => @@c_strings,
-      FORTRAN => @@f_strings
-    }
+    alias get_cl_strings get_c_strings
+    alias get_cuda_strings get_c_strings
 
     eval token_string_generator( * %w{while cond} )
     eval token_string_generator( * %w{end} )

data/lib/BOAST.rb

@@ -8,6 +8,7 @@ require 'BOAST/DataTypes.rb'
 require 'BOAST/Expression.rb'
 require 'BOAST/Index.rb'
 require 'BOAST/Variable.rb'
+require 'BOAST/Slice.rb'
 require 'BOAST/FuncCall.rb'
 require 'BOAST/Procedure.rb'
 require 'BOAST/Algorithm.rb'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: BOAST
 version: !ruby/object:Gem::Version
-  version: '0.99996'
+  version: '0.99997'
 platform: ruby
 authors:
 - Brice Videau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-08 00:00:00.000000000 Z
+date: 2015-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: narray
@@ -83,6 +83,7 @@ files:
 - lib/BOAST/Pragma.rb
 - lib/BOAST/Print.rb
 - lib/BOAST/Procedure.rb
+- lib/BOAST/Slice.rb
 - lib/BOAST/State.rb
 - lib/BOAST/Transitions.rb
 - lib/BOAST/Variable.rb