Vector ops

Like most wide-issue machines the Mill has a notion of “slot”, or scalar lane; one op can issue in each slot in each cycle, and can execute in any of the functional units attached to that slot using independent data. The data may be scalars from one byte up to the maximum supported scalar (64 or 128 bits depending on family member), or vectors of any scalar element size. That is, the architecture is fundamentally MIMD. The data paths feeding the FUs of the slots define a maximum operand width for data in the machine. This width is at least as big as the maximum scalar, but may be bigger so as to support larger vectors.

The con() op drops literal values to the belt. It is completely general and can drop any operand up to the maximum operand size, both scalar and vector. Scalars use the b/h/w/d/q width tags, and vectors use v, as in v16b. If every element of the literal has the same value, you may get better code by con()ing a scalar and extending it to vector with splat().

The rd() op is not general, but drops one of a member-dependent set of popCons (popular constants). If a particular literal is an available popcon then the specializer use the rd() op because it is more compact and does not plug up the flow-side slots that con() uses. Popcons may be scalar or vector, and each has a specific width that it drops; the same value but different widths are different popcons. Some popCons are always present on every member (0 and 1 of all scalar widths for example), and some are always present if the configuration includes hardware for which they would be useful (pi and e of relevant floating-point widths for members with FP for example). In addition, there will always be a few bit patterns left over after the configuration software has determined the bit patterns of all other operations configured in the readerBlock of the encoding (where the rd() op encodes). These are used to add additional popcons until all the bits are used up.

There are no reduction operations defined other than any() or all(). The alternate() op is a special form of vector swizzling that lets reductions be constructed in logN steps.

My shot at this using alternate:

 
// %0 contains [0,0,1,0]
// %1 contains [A,B,C,D]
F("pick_reduce_4") %0, %1;  
   pick      (%0, %1)        %2;     
   
   alternate (%2, %2)        %3 %4,
   recur     (%3, %4, %3)    %5;

   alternate (%5, %5)        %6 %7,
   recur     (%6, %7, %6)    %8;

   extract   (%8, w(0ul))   %9
   ret       (%9);

Some example runs:

   input: %0 = [1,0,0,0] %1 = [a,b,c,d]

   %2 = [a,,,]
   %3 = [a,a,,]   %4=[,,,]
   %5 = [a,a,,]
   %6 = [a,a,a,a] %7=[,,,]
   %8 = [a,a,a,a]
   %9 = a

   input: %0 = [0,1,0,0] %1 = [a,b,c,d]

   %2 = [,b,,]
   %3 = [,,b,b]      %4=[,,,]
   %5 = [,,b,b]
   %6 = [,,,]        %7=[b,b,b,b]
   %8 = [b,b,b,b]
   %9 = b

   input: %0 = [0,0,1,0] %1 = [a,b,c,d]

   %2 = [,,c,]
   %3 = [,,,]      %4=[c,c,,]
   %5 = [c,c,,]
   %6 = [c,c,c,c]  %7=[,,,]
   %8 = [c,c,c,c]
   %9 = c

   input: %0 = [0,0,0,1] %1 = [a,b,c,d]

   %2 = [,,,d]
   %3 = [,,,]      %4=[,,d,d]
   %5 = [,,d,d]
   %6 = [,,,]      %7=[d,d,d,d]
   %8 = [d,d,d,d]
   %9 = d

Shuffle is to reorder a vector? If I understand it correctly:

    shuffle ([a,b,c,d],  [3,2,1,0])  =  [d,c,b,a]
    shuffle ([a,b,c,d],  [1,1,1,1])  =  [b,b,b,b]
    shuffle ([a,b,c,d], [0, None, None, None]) = [a, None, None, None]

Then perhaps we can use the left operation to find the index of the selected element, this should work for vectors of any size and it would be O(1):

F("pick_reduce") %0, %1;  
   left       (%0)           %2;

   // this just builds a vector the same width as the data vector
   // the first element is the index of the element we want
   // the rest do not matter and can be junk
   inject     (%1, %2, 0)    %3;
   
   shuffle    (%1, %3)       %4;

   extract    (%4, 0)        %5,
   ret        (%5);   

If I understand correctly, the left operation will return the amount of leading zeroes. So if %0 = [0,0,1,0], then %2 will be 2.
Then I create a vector with that result as the first element in %3 and use that to shuffle the input vector, the first element in the result will be the element at position 2.

Is this correct Ivan?

• This reply was modified 7 years ago by  goldbug.
• This reply was modified 7 years ago by  goldbug.
• This reply was modified 7 years ago by  goldbug.

Duh, there is no need to shuffle:

F("pick_reduce") %0, %1;  
   left       (%0)           %2;

   extract    (%1, %2)        %3,
   ret        (%3);   

Simply get the index of the desired element and extract it. Just 2 instructions, that’s more like it.

• This reply was modified 7 years ago by  goldbug.