frontend: boolean tensors do not work

[AndreasKrall]

The following program:

instruction set architecture BoolArrayTest = {

using predicates = Bool<16>

}

gives the following error:

error: Invalid Type Notation
     ╭──[test.vadl:3:20]
     │
   3 │ using predicates = Bool<16>
     │                    ^^^^^^^^
     │
     The Bool type doesn't use the size notation.
     help: Try removing the size parameter here.

Boolean tensors have to be supported. Please add them in the near future.

[flofriday]

I don't think this should work. Bools represent single truth values, I think the suggested Bit Vectors would be better for that use case.

[AndreasKrall]

Of course I can define Bool<16> as Bits<16><1>, and rely on the implicit type conversion of a Bits<1> to Bool. This is currently the work around I use, but this does not look nice:

  constant VL        = 128              // vector length, number of bits in a vector register
  constant PL        = VL >> 3          // number of elements in a predicate register

  using IndexP = Bits4                  // index type for the 16 predicate register file
  using BitsP  = Bits<PL><1>            // Boolean type for predicate register file

  register   P : IndexP -> BitsP        // predicate register file

    instruction $i.id: SVEArithmeticPredFormat =
      let pred  = P(pg) in
      let left  = Z(zdn) as $BitsBHSD($size) in
      let right = Z(zm)  as $BitsBHSD($size) in 
        Z(zdn) := forall i : Index in 0..$elements-1
                    tensor if pred(i)
                      then VADL::$i.funct (left(i), right(i))
                      else left(i)

A Bool makes the meaning more clear. Of course we always will have the type equivalence of Bool<16><32> with Bits<16><32><1>.

[flofriday]

I somewhat disagree. If we add Bool-tensors to our typesystem it won't be as clear for many tasks when a BoolVector or BitVector should be used.

Like even I am confused what the differences would be? Should it also possible to do arithmetic operations on BoolVectors as it is on BitVectors?

Even more I would love to postpone this and add it to the discussion agenda, mostly because this will probably break a huge amount of assumptions we made in the typesystem and in the VIAM (there is currently no way to express tensors in the VIAM and so far we flattened all bit tensors to vectors but this won't be possible here).

[AndreasKrall]

Bits will not be the only tensors in the future. When we have floating point types, we also have to support Float tensors, probably both with builtin float types and with user defined float types. I don't see a problem that we have no Bool or Float in the VIAM. Bools are mapped to Bits<1> and Floats to Bits<32> or Bits<64>. We just have to make sure that correct builtins are called for overloaded operators. Everything, can be kept in the type system and it is not necessary that the type information is in the VIAM.

[Jozott00]

From my perspective a bool vector like Bool<4> is a type where the focus lies on the semantics of each element, not its combined value.

This differs from Bits<4>, which is read more like a value of four bits.

I would also say that there’s no strong integration of bool tensors into the typesystem, aside from the common tensor semantics and casts. Therefore, there’s no implicit casting to Bits<> or something similar. Considering this, it shouldn’t be too difficult to incorporate it into the tensor type system. However, I don’t have a strong opinion on this matter.

[AndreasKrall]

To clarify, Bool<4> is not equivalent to Bits<4>, it is equivalent to Bits<4><1>, which needs 4 bits as also Bits<4> does. This is a big difference.