Shared Memory

In Win32, memory can be shared amongst several processes on the same machine using file mapping.  Mechanical devices such as hard drives have very high access latencies and low transfer rates as compared to electrical devices such as memory.  Operating systems alleviate these discrepancies by using buffering techniques.  A buffer is nothing more than memory allocation that is used to hold information from the slower mechanical device.  The buffer caches all the data that is read from or written to the disk.   For example, a hundred bytes written to a file would be buffered with out actual writing to the file containing device.  If the same 100 bytes need to be read, they would be read from the buffer.  Reading from the buffer is far faster than, if the data was written to the disk, followed by a read of the disk drive.  If several processes need access to the same file at the same time, they all access it through the same buffer(to keep consistent reads and writes).  File mapping in win32 offers direct access to the user for this file buffer.  The file buffer space is mapped to the local process space of each of the processes.  Since memory is broken into pages, the buffer space is always rounded up to the next page size.

The CreateFileMapping function is used to create a file-mapping kernel object which is used to refer to the file buffer of a given file.  The function takes a handle to a file object as an argument.  File mapping kernel objects can either anonymous or named.  The CreateFileMapping function takes a name argument.  If the argument is NULL, than the file mapping object is anonymous.   If the argument is a non-NULL string, then the object is named.  If the object already exists, a reference to the existing file mapping object is returned. The OpenFileMapping function can be used to get access to the a named file mapping object.  The function MapViewOfFile is used to map the file buffer to the process space of the current process. It takes an argument of a handle to the file mapping object.  The return value of the function is a pointer to the beginning of the buffer in the processes own memory space.  If the process modifies memory locations in the buffer, when the file is finally closed and buffers flushed(written) to the disk, the file would be changed.  The function UnmapViewOfFile is used to remove the buffer from the current processes memory space.  The CloseHandle function can be used to close the a handle to the file-mapping kernel object.

If the CreateFileMapping function is passed a value 0xFFFFFFFF as an argument for the file handle(file whose buffer is going to be shared), the function will return a handle to a buffer that is not associated with any file.  This buffer can be used amongst several processes as shared memory.  Using OpenFileMapping is more difficult, due to writing code for creation and opening of file mapping kernels, as compared to that of just using CreateFileMapping function alone.

The CreateFileMapping takes arguments to specify the memory access rights.  If a file is opened for reading only and the handle is passed to CreateFileMapping, the associated buffer can only be read from.  It cannot be written to.  If an attempt is made to write to that memory, the process will receive a protection fault.   If a file is opened for both reading and writing, then the file mapping object can be created with a subset of the permissions.  The file mapping object can be made for reading and writing or only reading.

Using shared memory in conjunction with either interlocked functions or critical section objects is very efficient as compared to creating and using kernel objects such as semaphores, mutexes, and event objects.

The next program demonstrates the conversion of a file to upper case by first creating a file mapping for the ReadMe.txt text file.

The next program demonstrates access to shared memory.  Two processes access a ten buffers.  Each buffer has a maximum size of 100 bytes.  The first process is writer process that write information to the buffers in ascending order.  The second process is a reader that reads the buffers.  This is the standard reader-writer problem found in operating system courses.