Pack/unpack short into int

Question

I want to pack/unpack two signed 16 bit integers into a 32 bit integer. However, I'm not getting it to quite work.

Any ideas as to what I might be doing wrong?

template <typename T>
int read_s16(T& arr, int idx) restrict(amp)
{
    return static_cast<int>((arr[idx/2] >> ((idx % 2) * 16)) << 16) >> 16;
}

template<typename T>
void write_s16(T& arr, int idx, int val) restrict(amp)
{
    // NOTE: arr is zero initialized
    concurrency::atomic_fetch_or(&arr[idx/2], (static_cast<unsigned int>(val) & 0xFFFF) << ((idx % 2) * 16));
}

The function return/arguments must be as I have defined. The lo and hi are written from different threads (thus the atomic_or), and the read must return a single 32 bit value.

16 bit integer arithmetics are not supported on the target platform.

Example:

array<int> ar(1); // Container

write_s16(ar, 0, -16);
write_s16(ar, 1, 5);

assert(read_s16(ar, 0) == -16);
assert(read_s16(ar, 1) == 5);

Answer 1

These atomic operations in C++ AMP also have the following limitations:

• You should not mix atomic and normal (non-atomic) reads and writes. Normal reads may not see the results of atomic writes to the same memory location. Normal writes should not be mixed with atomic writes to the same memory location. If your program does not comply with these criteria then this will lead to an undefined result.
• Atomic operations do not imply a memory fence of any sort. Atomic operations may be reor-dered. This differs from the behavior of interlocked operations in C++.

It would seem like you are violating the first of these.