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, 1 month ago by  goldbug.

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, 1 month ago by  goldbug.
• This reply was modified 7 years, 1 month ago by  goldbug.
• This reply was modified 7 years, 1 month ago by  goldbug.

Hmmm, on second thought, maybe picking using a function result as selector is not that uncommon, for example:

if (isEmpty(mylist))
    return 3;
else
    return 5;

Sorry if I am wasting precious Ivan cycles.

I agree, it probably is not that common.

Regarding phasing. It would be highly undesireable to speculate calls. Calls will probably be expensive, may have side effects, and might cause your current belt to spill/fill, unlike say an add or a eql that have no side effects.

Therefore, would it not make more sense to move up the pick phase in front of call phase so that you can use picks to avoid calls? I assume the pick is currently after the calls because calls can return values, but if you think about it, you would never want to execute a call speculatively which greatly diminishes the value of picking call results.

This is a much more generic and common occurrence than the switch ranges.

I see the point. As it is the instruction set is beautiful for it’s uniformity and that betw operation would break that.

That is cool that you can use the pick results in the calltr. In the documentation it sounds like the pick phase is after the call phase so I was not sure.

The chain of less than is a great approach if you have a bunch of returns or branches, but it is not great when you have a bunch of calls. Consider this example:

int foo(int x)
{
   switch(x) {
      case 0:
      case 1:
      case 2:
         return bar();
      case 3:
      case 4:
      case 5:
         return baz();
      default:
         return 0;
   }
}

Since calls don’t stop execution, if you try to do a chain of lsss, you will end up calling bar multiple times. You can do this in one instruction if you checked ranges instead. Like this:

F("foo") %0;
    rd     (w(0ul))     %1,
    geqs   (%0, 0)      %2,
    leqs   (%0, 2)      %3,
    leqs   (%0, 5)      %4,
    pick   (%2, %3, %1) %5,    // range check x>=0 && x <= 2
    pick   (%3, %1, %4) %6,    // range check !(x<=2) && x <= 5   same as  x>=3 && x <=5
    calltr1 (%5, "bar") %7,    // call function only if in range a simple lsss would not be enough
    calltr1 (%6, "baz") %8,    // call function only if in range a simple lsss would not be enough
    retntr (%5, %7),
    retntr (%6, %8),
    retn (%1);

I would think that switching function calls is common, perhaps not with ranges though, so maybe I am overthinking it.