Thread: Possible to pack smaller data types into larger ones?

Hi,
I had a thought the other day, about packing two or more data type's into another larger data type. Then perform some addition/subraction operations on the larger data type, so you basically get two operations for the price of one.

Here is an example of what i mean:

short int a,b,c,d;
unsigned short int ab,cd;
long int e,f,result;

/* pack a & b into e */
/* pack c & d into f */

result = e + f;

/* unpack e and f, store in ab and cd */

Would ab now hold a+b, and cd hold c+d?

Say two chars were packed into a short...
12345678 | 12345678
----------------------------
00000001 | 00000001 dec 513 OR 1 and 1 as 2 chars
00000001 | 00000001 dec 513 OR 1 and 1 as 2 chars
*PERFORM*ADDITION*
00000010 | 00000010 dec 1026 OR 2 and 2 as two chars

I take it that the above would save an addition operation, instead of adding 2 chars to one another, then adding another 2 chars to one another.
Assuming that all this is possible, I would guess that there would be some sort of overhead involved in packing and unpacking, but how much?

I am quite new to C, so if I appear to have been on the crack pipe, please say.
I am just interested in the proof of concept of doing this, or ideally, any real world examples of it.

<kicks himself>
Well, I found that union's are able to do this very easily, so I shall experiment with them for a while.

Anybody think of any other ways?

If you are on the Intel/AMD plattform, have a look at the following webpages:

http://gcc.gnu.org/onlinedocs/gcc/X8...Functions.html
http://gcc.gnu.org/onlinedocs/gcc/Ve...r%20Extensions

example source code for SSE instructions:

Code:

typedef float v4sf __attribute__ ((mode(V4SF)));

v4sf v1, v2;
float data[8], tmp[4]; 
/* fill array data */
...
v1 = __builtin_ia32_loadaps(data);
v2 = __builtin_ia32_loadaps(&data[4]);
v1 = __builtin_ia32_mulps(v1, v2);
__builtin_ia32_storeaps(tmp, v1);

Now, the content of the array tmp is as follows:
tmp[0] = data[0] * data[4];
tmp[1] = data[1] * data[5];
tmp[1] = data[2] * data[6];
tmp[1] = data[3] * data[7];