Reading different data types in shared memory

Question

I want to share some memory between different processes running a DLL. Therefore i create a memory-mapped-file by HANDLE hSharedFile = CreateFileMapping(...) then LPBYTE hSharedView = MapViewOfFile(...) and LPBYTE aux = hSharedView

Now I want to read a bool, a int, a float and a char from the aux array. Reading a bool and char is easy. But how would I go around reading a int or float? Notice that the int or float could start at position 9 e.g. a position that is not dividable by 4.

I know you can read a char[4] and then memcpy it into a float or int. But i really need this to be very fast. I am wondering if it is possible to do something with pointers?

Thanks in advance

Answer 1

If you know, for instance, that array elements aux[13..16] contain a float, then you can access this float in several ways:

float f = *(float*)&aux[13] ;   // Makes a copy. The simplest solution.
float* pf = (float*)&aux[13] ;  // Here you have to use *pf to access the float.
float& rf = *(float*)&aux[13] ; // Doesn't make a copy, and is probably what you want.
                                // (Just use rf to access the float.)

Answer 2

There is nothing wrong with grabbing an int at offset 9:

int* intptr = (int*) &data[9];

int mynumber = *intptr;

_{There might be a really tiny performance penalty for this "unaligned" access, but it will still work correctly, and the chances of you noticing any differences are slim.}

Answer 3

First of all, I think you should measure. There are three options you can go with that I can think of:

• with unaligned memory
• with memcpy into buffers
• with custom-aligned memory

Unaligned memory will work fine, it will just be slower than aligned. How slower is that, and does it matter to you? Measure to find out.

Copying into a buffer will trade off the slower unaligned accesses for additional copy operations. Measuring will tell you if it's worth it.

If using unaligned memory is too slow for you and you don't want to copy data around (perhaps because of the performance cost), then you can possibly do faster by wasting some memory space and increasing your program complexity. Don't use the mapped memory blindly: round your "base" pointer upwards to a suitable value (e.g. 8 bytes) and only do reads/writes at 8-byte increments of this "base" value. This will ensure that all your accesses will be aligned.

But do measure before you go into all this trouble.