-----Original Message-----
From: Mike Acton 
Sent: Monday, March 26, 2007 2:50 AM
To: Mike Day; tech
Subject: RE: curiously small code...

Hey Mike,

Using fsm* and gb* this way is definitely very cool! I think what you have below would be tough to beat for scalar values. And I think you've opened the door for a lot more uses of those instructions.

I noticed something though: The values don't match exactly between your previous example and this one for the unswizzle. It's basically one-off.  If you look at your iterative version (below), the value at (i) is equal to your new unswizzle8( i+1 ).

// Previous iterative version (unswizzle)
{
  u32 x=0, y=0;

  for (u32 i=0; i<num_texels; i++)
  {
    u32 and0 = x & y;
    u32 and1 = and0 + 1;
    u32 xinc = and0 ^ and1;
    u32 yinc = x & xinc;

    x ^= xinc;
    y ^= yinc;
}

For the swizzle: If we're working on uniform vectors of coordinates (rather than scalars) I don't think the fsmh+gbb approach is a win - but I'm not sure if your actual case can work with multiple coordinates at once.

For full quadwords, I think the following would still be about twice as fast:

// swizzle8 x 8
// Interleave the low byte of each halfword of x and y into each halfword of the result.
// (Assumes upper byte of each halfword is zero.)
qword
swizzle_lo8( qword x, qword y )
{
    // Expand(x) -- Shift left each bit by bit index. Zero unused bits.
    qword x20 = si_shlhi( x, 0x04 );
    qword x21 = si_or( x, x20 );
    qword x22 = si_andbi( x21, 0x0f );
    qword x30 = si_shlhi( x22, 0x02 );
    qword x31 = si_or( x22, x30 );
    qword x32 = si_andbi( x31, 0x33 );
    qword x40 = si_shlhi( x32, 0x01 );
    qword x41 = si_or( x32, x40 );
    qword x42 = si_andbi( x41, 0x55 );

    // Expand(y) -- Shift left each bit by bit index. Zero unused bits.
    qword y20 = si_shlhi( y, 0x04 );
    qword y21 = si_or( y, y20 );
    qword y22 = si_andbi( y21, 0x0f );
    qword y30 = si_shlhi( y22, 0x02 );
    qword y31 = si_or( y22, y30 );
    qword y32 = si_andbi( y31, 0x33 );
    qword y40 = si_shlhi( y32, 0x01 );
    qword y41 = si_or( y32, y40 );
    qword y42 = si_andbi( y41, 0x55 );

    // Combine.
    qword z00 = si_shlhi( y42, 0x01 );
    qword z01 = si_or( x42, z00 );

    return z01;
}

...and for 16 bits:

// swizzle16 x 4
// Interleave the low halfword of each word of x and y into each word of the result.
// (Assumes upper halfword of each word is zero.)
qword
swizzle_lo16( qword x, qword y )
{
    // Expand(x) -- Shift left each bit by bit index. Zero unused bits.
    qword x10 = si_shlhi( x, 0x08 );
    qword x11 = si_or( x, x10 );
    qword x12 = si_andhi( x11, 0x00ff );
    qword x20 = si_shli( x12, 0x04 );
    qword x21 = si_or( x12, x20 );
    qword x22 = si_andbi( x21, 0x0f );
    qword x30 = si_shli( x22, 0x02 );
    qword x31 = si_or( x22, x30 );
    qword x32 = si_andbi( x31, 0x33 );
    qword x40 = si_shli( x32, 0x01 );
    qword x41 = si_or( x32, x40 );
    qword x42 = si_andbi( x41, 0x55 );

    // Expand(y) -- Shift left each bit by bit index. Zero unused bits.
    qword y10 = si_shlhi( y, 0x08 );
    qword y11 = si_or( y, y10 );
    qword y12 = si_andhi( y11, 0x00ff );
    qword y20 = si_shli( y12, 0x04 );
    qword y21 = si_or( y12, y20 );
    qword y22 = si_andbi( y21, 0x0f );
    qword y30 = si_shli( y22, 0x02 );
    qword y31 = si_or( y22, y30 );
    qword y32 = si_andbi( y31, 0x33 );
    qword y40 = si_shli( y32, 0x01 );
    qword y41 = si_or( y32, y40 );
    qword y42 = si_andbi( y41, 0x55 );

    // Combine.
    qword z00 = si_shli( y42, 0x01 );
    qword z01 = si_or( x42, z00 );

    return z01;
}
 
Mike.