Class: BOAST::Operator

Inherits:
Object show all
Defined in:
lib/BOAST/Operators.rb

Direct Known Subclasses

Affectation, BasicBinaryOperator, Minus, Not, Set

Class Method Summary collapse

Class Method Details

.convert(arg, type) ⇒ Object 



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/BOAST/Operators.rb', line 53

def Operator.convert(arg, type)
  case BOAST::get_architecture
  when X86
    s1 = arg.type.total_size*8
    s2 = type.total_size*8
    n1 = get_vector_name(arg.type)
    n2 = get_vector_name(type)
    if s1 <= 128 and s2 <= 128 then
      return "_mm_cvt#{n1}_#{n2}( #{arg} )"
    elsif [s1, s2].max <= 256 then
      return "_mm256_cvt#{n1}_#{n2}( #{arg} )"
    elsif [s1, s2].max <= 512 then
      return "_mm512_cvt#{n1}_#{n2}( #{arg} )"
    end
  when ARM
    if type.class != arg.type.class then
      if type.size == arg.type.size then
        s = type.total_size*8
        n1 = get_vector_name(arg.type)
        n2 = get_vector_name(type)
        return "vcvt#{ s == 128 ? "q" : "" }_#{n2}_#{n1}( #{arg} )"
      elsif type.class == Real then
        intr = convert(arg, arg.type.copy(:size=>type.size))
        return convert(arg.copy(intr, :size => type.size ), type)
      else
        n1 = get_vector_name(arg.type)
        s = type.total_size*8
        t2 = type.copy(:size => arg.type.size)
        n2 = get_vector_name( t2 )
        intr = "vcvt#{ s == 128 ? "q" : "" }_#{n2}_#{n1}( #{arg} )"
        return convert(Variable::from_type(intr, t2), type)
      end
    elsif type.class != Real then
      n = get_vector_name(arg.type)
      if type.size == arg.type.size then
        if type.signed == arg.type.signed then
          return "#{arg}"
        else
          n2 = get_vector_name(type)
          return "vreinterpret_#{n2}_#{n}( #{arg} )"
        end
      elsif type.size < arg.type.size then
        intr = "vmovn_#{n}( #{arg} )"
        s = arg.type.size/2
      else
        intr = "vmovl_#{n}( #{arg} )"
        s = arg.type.size*2
      end
      return convert(arg.copy(intr, :size => s), type)
    end
  else
    raise "Unsupported architecture!"
  end
end

.get_vector_name(type) ⇒ Object 



4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/BOAST/Operators.rb', line 4

def Operator.get_vector_name(type)
  case BOAST::get_architecture
  when X86
    case type
    when Int
      size = "#{type.size*8}"
      name = ""
      if type.total_size*8 > 64
        name += "e"
      end
      if type.vector_length > 1 then
        name += "p"
      else
        name = "s"
      end
      if type.signed then
        name += "i"
      else
        name += "u"
      end
      return name += size
    when Real
      case type.size
      when 4
        return "ps" if type.vector_length > 1
        return "ss"
      when 8
        return "pd" if type.vector_length > 1
        return "sd"
      end
    else
      raise "Undefined vector type!"
    end
  when ARM
    case type
    when Int
      name = "#{ type.signed ? "s" : "u" }"
      name += "#{ type.size * 8}"
      return name
    when Real
      return "f#{type.size*8}"
    else
      raise "Undefined vector type!"
    end
  else
    raise "Unsupported architecture!"
  end
end