Question

It struck me there must be a clever way to do this. This isn’t for homework, or work or anything. I was just noodling around with a file format that has data interleaved.

So, in generic C/C++, (or whatever) given some array

int x[] = ...

is there a clever way of splitting it into two short arrays

short sa1[], sa2[]

such that the int array is split down the middle

x[i] = 1111111111111111 1111111111111111
             sa1[i]         sa2[i]

Edit: Sorry if this is not phrased well. For each i-th element of the int array, the left-most 16 bits become the i-th element of one array, and the right-most 16bits become the i-th element of a 2nd array.

so given

x[i] = 0001111111111111 1111111100011111

then

sa1[i] = 0001111111111111
sa2[i] = 1111111100011111

I’m looking for non-obvious answers that do not loop over each element and shift and mask each element. That’s easy 🙂

Answer 1

There’s a lot of ways to do this:

Assumptions:

1. short is 16 bits.
2. int is 32 bits.

Method 1: (A simple loop)

for (int i = 0; i < size; i++){
    int tmp = x[i];
    sa1[i] = (tmp      ) & 0xffff;
    sa2[i] = (tmp >> 16) & 0xffff;
}

Method 2: SSE2

for (int i = 0; i < size / 8; i++){
    __m128i a0 = ((__m128i*)x)[2*i + 0];
    __m128i a1 = ((__m128i*)x)[2*i + 1];

    a0 = _mm_shufflelo_epi16(a0,216);
    a1 = _mm_shufflelo_epi16(a1,216);
    a0 = _mm_shufflehi_epi16(a0,216);
    a1 = _mm_shufflehi_epi16(a1,216);
    a0 = _mm_shuffle_epi32(a0,216);
    a1 = _mm_shuffle_epi32(a1,216);

    ((__m128i*)sa1)[i] = _mm_unpacklo_epi64(a0,a1);
    ((__m128i*)sa2)[i] = _mm_unpackhi_epi64(a0,a1);
}

This last example is very fast if the loop is further unrolled. I won’t be surprised if this can beat all byte-manipulation libraries.

However, it has the following restrictions:

1. The data must be aligned to 16 bytes.
2. The number of iterations must be divisible by 8.
3. It requires SSE2.

The first two of these can be solved by cleanup code. It’s messy, but if you really desire performance, it may be worth it.

EDIT:

Yes this violates strict-aliasing, but it’s nearly impossible to use SSE intrinsics without doing so.