BOAST 2.0.2 → 2.1.0

data/lib/BOAST/Language/Operators.rb

@@ -38,7 +38,7 @@ module BOAST
   class BasicBinaryOperator < Operator
 
     def BasicBinaryOperator.string(arg1, arg2, return_type)
-      if lang == C and (arg1.class == Variable and arg2.class == Variable) and (arg1.type.vector_length > 1 or arg2.type.vector_length > 1) then
+      if lang == C and (arg1.instance_of? Variable and arg2.instance_of? Variable) and (arg1.type.vector_length > 1 or arg2.type.vector_length > 1) then
         instruction = intrinsics(intr_symbol, return_type.type)
         a1 = convert(arg1, return_type.type)
         a2 = convert(arg2, return_type.type)
@@ -357,7 +357,7 @@ module BOAST
       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
+        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
@@ -434,7 +434,7 @@ module BOAST
           if lang == CL then
             return @return_type.copy("(#{@return_type.type.decl})( #{eff_src} )", DISCARD_OPTIONS) if lang == CL
           end
-          if (@source.is_a?(Numeric) and @source == 0) or (@source.class == Variable and @source.constant == 0) then
+          if (@source.is_a?(Numeric) and @source == 0) or (@source.instance_of? Variable and @source.constant == 0) then
             begin
               instruction = intrinsics(:SETZERO, @return_type.type)
               return @return_type.copy("#{instruction}( )", DISCARD_OPTIONS) if instruction
@@ -464,9 +464,9 @@ module BOAST
 
     def pr
       s=""
-      s += indent
-      s += to_s
-      s += ";" if [C, CL, CUDA].include?( lang )
+      s << indent
+      s << to_s
+      s << ";" if [C, CL, CUDA].include?( lang )
       output.puts s
       return self
     end
@@ -500,9 +500,9 @@ module BOAST
       tar = @target.to_var if @target.respond_to?(:to_var)
       src = @source
       src = @source.to_var if @source.respond_to?(:to_var)
-      if tar.class == Variable and tar.type.vector_length > 1 then
+      if tar.instance_of? Variable and tar.type.vector_length > 1 then
         return @target.copy("#{@target} = #{Load(@source, @target, @options)}", DISCARD_OPTIONS)
-      elsif src.class == Variable and src.type.vector_length > 1 then
+      elsif src.instance_of? Variable and src.type.vector_length > 1 then
         r_t, _ = transition(tar, src, Affectation)
         opts = @options.clone
         opts[:store_type] = r_t
@@ -517,9 +517,9 @@ module BOAST
 
     def pr
       s=""
-      s += indent
-      s += to_s
-      s += ";" if [C, CL, CUDA].include?( lang )
+      s << indent
+      s << to_s
+      s << ";" if [C, CL, CUDA].include?( lang )
       output.puts s
       return self
     end
@@ -555,7 +555,7 @@ module BOAST
       if lang == C or lang == CL then
         if @source.kind_of?(Array) then
           return Set(@source, @return_type).to_var
-        elsif @source.class == Variable or @source.respond_to?(:to_var) then
+        elsif @source.instance_of? Variable or @source.respond_to?(:to_var) then
           src_var = source.to_var
           if src_var.type == @return_type.type then
             return src_var
@@ -574,14 +574,14 @@ module BOAST
             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 += "_"
+              sym << "MASK"
+              sym << "Z" if @zero
+              sym << "_"
             end
             if src_var.alignment and @return_type.type.total_size and ( src_var.alignment % @return_type.type.total_size ) == 0 then
-              sym += "LOADA"
+              sym << "LOADA"
             else
-              sym += "LOAD"
+              sym << "LOAD"
             end
             instruction = intrinsics( sym.to_sym, @return_type.type)
             if mask and not mask.full? then
@@ -596,7 +596,7 @@ module BOAST
       elsif lang == FORTRAN then
         if @source.kind_of?(Array) then
           return Set(@source, @return_type).to_var
-        elsif @source.class == Variable or @source.respond_to?(:to_var) then
+        elsif @source.instance_of? Variable or @source.respond_to?(:to_var) then
           if @source.to_var.type == @return_type.type then
             return @source.to_var
           elsif @source.kind_of?(Index) and @return_type.type.vector_length > 1 then
@@ -613,9 +613,9 @@ module BOAST
 
     def pr
       s=""
-      s += indent
-      s += to_s
-      s += ";" if [C, CL, CUDA].include?( lang )
+      s << indent
+      s << to_s
+      s << ";" if [C, CL, CUDA].include?( lang )
       output.puts s
       return self
     end
@@ -667,7 +667,7 @@ module BOAST
         src = src[1..-1]
       end
       p_type = type.copy(:vector_length => 1)
-      s += "#{instruction}( (#{p_type.decl} * ) #{src}, #{get_mask} )"
+      s << "#{instruction}( (#{p_type.decl} * ) #{src}, #{get_mask} )"
       return @return_type.copy( s, DISCARD_OPTIONS)
     end
 
@@ -677,9 +677,9 @@ module BOAST
 
     def pr
       s=""
-      s += indent
-      s += to_s
-      s += ";" if [C, CL, CUDA].include?( lang )
+      s << indent
+      s << to_s
+      s << ";" if [C, CL, CUDA].include?( lang )
       output.puts s
       return self
     end
@@ -725,11 +725,11 @@ module BOAST
         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?
+        sym << "MASK_" if mask and not mask.full?
         if @dest.alignment and type.total_size and ( @dest.alignment % type.total_size ) == 0 then
-          sym += "STOREA"
+          sym << "STOREA"
         else
-          sym += "STORE"
+          sym << "STORE"
         end
         instruction = intrinsics(sym.to_sym, type)
         p_type = type.copy(:vector_length => 1)
@@ -746,9 +746,9 @@ module BOAST
 
     def pr
       s=""
-      s += indent
-      s += to_s
-      s += ";" if [C, CL, CUDA].include?( lang )
+      s << indent
+      s << to_s
+      s << ";" if [C, CL, CUDA].include?( lang )
       output.puts s
       return self
     end
@@ -799,16 +799,16 @@ module BOAST
         dst = dst[1..-1]
       end
       p_type = type.copy(:vector_length => 1)
-      return s += "#{instruction}( (#{p_type.decl} * ) #{dst}, #{get_mask}, #{Operator.convert(@source, type)} )"
+      return s << "#{instruction}( (#{p_type.decl} * ) #{dst}, #{get_mask}, #{Operator.convert(@source, type)} )"
     end
 
     def pr
       ss = to_s
       if ss then
         s=""
-        s += indent
-        s += ss
-        s += ";" if [C, CL, CUDA].include?( lang )
+        s << indent
+        s << ss
+        s << ";" if [C, CL, CUDA].include?( lang )
         output.puts s
       end
       return self
@@ -877,9 +877,9 @@ module BOAST
 
     def pr
       s=""
-      s += indent
-      s += to_s
-      s += ";" if [C, CL, CUDA].include?( lang )
+      s << indent
+      s << to_s
+      s << ";" if [C, CL, CUDA].include?( lang )
       output.puts s
       return self
     end
@@ -948,9 +948,9 @@ module BOAST
 
     def pr
       s=""
-      s += indent
-      s += to_s
-      s += ";" if [C, CL, CUDA].include?( lang )
+      s << indent
+      s << to_s
+      s << ";" if [C, CL, CUDA].include?( lang )
       output.puts s
       return self
     end
@@ -982,9 +982,9 @@ module BOAST
 
     def pr
       s=""
-      s += indent
-      s += to_s
-      s += ";" if [C, CL, CUDA].include?( lang )
+      s << indent
+      s << to_s
+      s << ";" if [C, CL, CUDA].include?( lang )
       output.puts s
       return self
     end
@@ -1002,7 +1002,7 @@ module BOAST
     def to_s_fortran
       op1, op2 = op_to_var
       if @return_type and @return_type.type.kind_of?(Real) and ( not op1.type.kind_of?(Real) or not op2.type.kind_of?(Real) ) then
-        return "modulo(real(#{op1}, #{@return_type.type.size}), #{op2})" if not op1.type.kind_of?(Real)
+        return "modulo(real(#{op1}, #{@return_type.type.size}), #{op2})" unless op1.type.kind_of?(Real)
         return "modulo(#{op1}, real(#{op2}, #{@return_type.type.size}))"
       else
         return "modulo(#{op1}, #{op2})"
@@ -1013,12 +1013,24 @@ module BOAST
       op1, op2 = op_to_var
       if @return_type and @return_type.type.kind_of?(Real) then
         if @return_type.type.size <= 4 then
-          return "((#{op1} < 0) ^ (#{op2} < 0) ? fmodf(#{op1}, #{op2}) + #{op2} : fmodf(#{op1}, #{op2}));"
+          return "((#{op1} < 0) ^ (#{op2} < 0) ? fmodf(#{op1}, #{op2}) + #{op2} : fmodf(#{op1}, #{op2}))"
         else
           return "((#{op1} < 0) ^ (#{op2} < 0) ? fmod(#{op1}, #{op2}) + #{op2} : fmod(#{op1}, #{op2}))"
         end
       else
-        return "((#{op1} < 0) ^ (#{op2} < 0) ? (#{op1} % #{op2}) + #{op2} : #{op1} % #{op2})"
+        test_op1 = true
+        test_op1 = false if op1.respond_to?(:type) and op1.type.respond_to?(:signed?) and not op1.type.signed?
+        test_op2 = true
+        test_op2 = false if op2.respond_to?(:type) and op2.type.respond_to?(:signed?) and not op2.type.signed?
+        if test_op1 and test_op2 then
+          return "((#{op1} < 0) ^ (#{op2} < 0) ? (#{op1} % #{op2}) + #{op2} : #{op1} % #{op2})"
+        elsif test_op1 then
+          return "( (#{op1} < 0) ? (#{op1} % #{op2.cast(op1)}) + #{op2} : #{op1} % #{op2})"
+        elsif test_op2 then
+          return "( (#{op2} < 0) ? (#{op1.cast(op2)} % #{op2}) + #{op2} : #{op1} % #{op2})"
+        else
+          return "(#{op1} % #{op2})"
+        end
       end
     end
 
@@ -1056,9 +1068,9 @@ module BOAST
 
     def pr
       s=""
-      s += indent
-      s += to_s
-      s += ";" if [C, CL, CUDA].include?( lang )
+      s << indent
+      s << to_s
+      s << ";" if [C, CL, CUDA].include?( lang )
       output.puts s
       return self
     end

data/lib/BOAST/Language/Pragma.rb

@@ -17,19 +17,19 @@ module BOAST
     def to_s
       s = ""
       if lang == FORTRAN then
-        s += "!#{@name}$"
+        s << "!#{@name}$"
       else
-        s += "#pragma #{name}"
+        s << "#pragma #{name}"
       end
       @options.each{ |opt|
-        s += " #{opt}"
+        s << " #{opt}"
       }
       return s
     end
 
     def pr
       s=""
-      s += to_s
+      s << to_s
       output.puts s
       return self
     end

data/lib/BOAST/Language/Procedure.rb

@@ -39,14 +39,14 @@ module BOAST
     # @private
     def boast_header(lang=C)
       s = boast_header_s(lang)
-      s += ";\n"
+      s << ";\n"
       output.print s
       return self
     end
 
     def call(*parameters)
       prefix = ""
-      prefix += "call " if lang==FORTRAN and @properties[:return].nil?
+      prefix << "call " if lang==FORTRAN and @properties[:return].nil?
       f = FuncCall::new(@name, *parameters, :return => @properties[:return] )
       f.prefix = prefix
       return f
@@ -114,50 +114,50 @@ module BOAST
       s = ""
       if lang == CL then
         if @properties[:local] then
-          s += "#if __OPENCL_C_VERSION__ && __OPENCL_C_VERSION__ >= 120\n"
-          s += "static\n"
-          s += "#endif\n"
+          s << "#if __OPENCL_C_VERSION__ && __OPENCL_C_VERSION__ >= 120\n"
+          s << "static\n"
+          s << "#endif\n"
         else
-          s += "__kernel "
+          s << "__kernel "
           wgs = @properties[:reqd_work_group_size]
           if wgs then
-            s += "__attribute__((reqd_work_group_size(#{wgs[0]},#{wgs[1]},#{wgs[2]}))) "
+            s << "__attribute__((reqd_work_group_size(#{wgs[0]},#{wgs[1]},#{wgs[2]}))) "
           end
         end
       elsif lang == CUDA then
         if @properties[:local] then
-          s += "static __device__ "
+          s << "static __device__ "
         else
-          s += "__global__ "
+          s << "__global__ "
           wgs = @properties[:reqd_work_group_size]
           if wgs then
-            s += "__launch_bounds__(#{wgs[0]}*#{wgs[1]}*#{wgs[2]}) "
+            s << "__launch_bounds__(#{wgs[0]}*#{wgs[1]}*#{wgs[2]}) "
           end
         end
       elsif lang == C then
         if @properties[:local] then
-          s += "static "
+          s << "static "
         end
         if @properties[:inline] then
-          s+= "inline "
+          s << "inline "
         end
       end
       if @properties[:qualifiers] then
-        s += "#{@properties[:qualifiers]} "
+        s << "#{@properties[:qualifiers]} "
       end
       if @properties[:return] then
-        s += "#{@properties[:return].type.decl} "
+        s << "#{@properties[:return].type.decl} "
       else
-        s += "void "
+        s << "void "
       end
-      s += "#{@name}("
+      s << "#{@name}("
       if @parameters.first then
-        s += @parameters.first.send(:decl_c_s, @properties[:local])
+        s << @parameters.first.send(:decl_c_s, @properties[:local])
         @parameters[1..-1].each { |p|
-          s += ", "+p.send(:decl_c_s, @properties[:local])
+          s << ", "+p.send(:decl_c_s, @properties[:local])
         }
       end
-      s += ")"
+      s << ")"
       return s
     end
 
@@ -170,13 +170,13 @@ module BOAST
     def to_s_fortran
       s = ""
       if @properties[:return] then
-        s += "#{@properties[:return].type.decl} FUNCTION "
+        s << "#{@properties[:return].type.decl} FUNCTION "
       else
-        s += "SUBROUTINE "
+        s << "SUBROUTINE "
       end
-      s += "#{@name}("
-      s += @parameters.collect(&:name).join(", ")
-      s += ")"
+      s << "#{@name}("
+      s << @parameters.collect(&:name).join(", ")
+      s << ")"
     end
 
     def open_c
@@ -205,7 +205,7 @@ module BOAST
 
     def open_fortran
       s = indent + to_s_fortran
-      s += "\n"
+      s << "\n"
       increment_indent_level
       tmp_buff = StringIO::new
       push_env( :output => tmp_buff ) {
@@ -214,8 +214,8 @@ module BOAST
         }
       }
       tmp_buff.rewind
-      s += tmp_buff.read
-      s += indent + "integer, parameter :: wp=kind(1.0d0)"
+      s << tmp_buff.read
+      s << indent + "integer, parameter :: wp=kind(1.0d0)"
       output.puts s
       @constants.each { |c|
         BOAST::decl c
@@ -247,9 +247,9 @@ module BOAST
 
     def close_c
       s = ""
-      s += indent + "return #{@properties[:return]};\n" if @properties[:return]
+      s << indent + "return #{@properties[:return]};\n" if @properties[:return]
       decrement_indent_level
-      s += indent + "}"
+      s << indent + "}"
       output.puts s
       return self
     end
@@ -257,12 +257,12 @@ module BOAST
     def close_fortran
       s = ""
       if @properties[:return] then
-        s += indent + "#{@name} = #{@properties[:return]}\n"
+        s << indent + "#{@name} = #{@properties[:return]}\n"
         decrement_indent_level
-        s += indent + "END FUNCTION #{@name}"
+        s << indent + "END FUNCTION #{@name}"
       else
         decrement_indent_level
-        s += indent + "END SUBROUTINE #{@name}"
+        s << indent + "END SUBROUTINE #{@name}"
       end
       output.puts s
       return self
@@ -271,38 +271,38 @@ module BOAST
     def boast_header_s( lang=C )
       s = ""
       headers.each { |h|
-        s += "#include <#{h}>\n"
+        s << "#include <#{h}>\n"
       }
       if lang == CL then
-        s += "__kernel "
+        s << "__kernel "
         wgs = @properties[:reqd_work_group_size]
         if wgs then
-          s += "__attribute__((reqd_work_group_size(#{wgs[0]},#{wgs[1]},#{wgs[2]}))) "
+          s << "__attribute__((reqd_work_group_size(#{wgs[0]},#{wgs[1]},#{wgs[2]}))) "
         end
       end
       trailer = ""
-      trailer += "_" if lang == FORTRAN
-      trailer += "_wrapper" if lang == CUDA
+      trailer << "_" if lang == FORTRAN
+      trailer << "_wrapper" if lang == CUDA
       if @properties[:return] then
-        s += "#{@properties[:return].type.decl} "
+        s << "#{@properties[:return].type.decl} "
       elsif lang == CUDA
-        s += "unsigned long long int "
+        s << "unsigned long long int "
       else
-        s += "void "
+        s << "void "
       end
-      s += "#{@name}#{trailer}("
+      s << "#{@name}#{trailer}("
       if @parameters.first then
-        s += @parameters.first.boast_header(lang)
+        s << @parameters.first.boast_header(lang)
         @parameters[1..-1].each { |p|
-          s += ", "
-          s += p.boast_header(lang)
+          s << ", "
+          s << p.boast_header(lang)
         }
       end
       if lang == CUDA then
-        s += ", " if parameters.first
-        s += "size_t *_boast_block_number, size_t *_boast_block_size, int _boast_repeat"
+        s << ", " if parameters.first
+        s << "size_t *_boast_block_number, size_t *_boast_block_size, int _boast_repeat"
       end
-      s += ")"
+      s << ")"
       return s
     end