|
|
The data stored in a
file resides permanently in your computer hard disk. This data is
loaded in to main memory (also known as RAM) of your computer before
it can be used for any processing. This data transfer from hard disk
to RAM takes certain amount of time to load. If the data is large in
size the transfer time is noticeable. In 32-bit operating systems,
the size of a single data file could be up to 2 GB. But suppose the
RAM size is only 512 MB or 1 GB, then the complete data file of 2 GB
can not be fitted in to the RAM. In such cases, it is the
programmer’s responsibility to read the data in parts. But reading
the data in parts will not always give the solution to this problem.
To handle such issues, Microsoft has given a very flexible feature
of Memory mapped files.
Using this technique, you can actually virtually map the data file
on the disk and create a view of it as it is stored in RAM. There is
no need to load the data file in to RAM. Windows kernel
automatically handles the buffering between memory and disk. It can
be implemented in the following three steps.
First Step : Create a file Object
Open the data file using the standard function call CreateFile( ).
Its prototype looks like this
HANDLE hfile = CreateFile(
LPCTSTR lpFileName,
DWORD dwDesiredAccess,
DWORD dwShareMode,
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
DWORD dwCreationDistribution,
DWORD dwFlagsAndAttributes,
HANDLE hTemplateFile
);
lpFileName
A line pointer to name of the file.
dwDesiredAccess
Access mode (read/write)
dwShareMode
Specify the share mode. (whether to share it with other processes or
not).
lpSecurityAttributes
A pointer to security descriptor.
dwCreattionDistribution
Specify the action required if file exists or do not exists.
dwFlagsAndAttributes
Specify file attributes and flags.
hTemplateFile
A handle to the file with attributes to copy.
The sample call of this function is shown below. We will assume that
we would like to memory map file “mydata.dat”.
HANDLE hfile = CreateFile(
“mydata.dat”,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_READONLY | FILE_FLAG_RANDOM_ACCESS,
NULL
);
Second Step : Create a file mapping object
Once you have create the handle of a open file, now create a map of
the open file using the following function call.
HANDLE hnd = CreateFileMapping(
HANDLE hFile,
LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
DWORD flProtect,
DWORD dwMaximumSizeHigh,
DWORD dwMaximumSizeLow,
LPCTSTR lpName
);
hFile
File handle of the file to be mapped.
lpFileMappingAttributes
Security attributes for the mapping object.
flProtect
Protection attribute for the file when the file is mapped.
dwMaximumSizeHigh
High order 32 bits of maximum size of the file mapping object.
dwMaximumSizeLow
Low order 32 bits of maximum size of the file mapping object.
lpName
A NULL terminated string to specify the name of the mapping object.
The sample code to use this function is as follows.
HANDLE hnd = CreateFileMapping(
hfile,
NULL,
PAGE_READONLY,
0,
0,
NULL
);
Step 3: Create a view of the mapped file
Now the final step is to create a view of the mapped file. After
this step the returned pointer can straightway be used to access
data. The function call is as under.
LPVOID *ptr = MapViewOfFile(
HANDLE hFileMappingObject,
DWORD dwDesiredAccess,
DWORD dwFileOffsetHigh,
DWORD dwFileOffsetLow,
DWORD dwNumberOfBytesToMap
);
hFileMappingObject
An Open file mapping object handle.
dwDesiredAccess
Specify the type of file view access, like read only access or
read-write access etc.
dwFileOffsetHigh
High order 32 bit position of the file offset to start the mapping.
dwFileOffsetLow
Low order 32 bit position of the file offset to start the mapping.
dwNumberOfBytesToMap
Number of file’s bytes that are mapped. Use zero to map the entire
file.
The sample code to use this function is as follows.
Unsigned char *mapview = (unsigned char*)MapViewOfFile(
hnd,
FILE_MAP_READ,
0,
0,
0);
Now the process of creating a memory mapped file is over. The
mapview pointer can be used to access the data from the file
assuming that it is stored in an array. So Simple!!!
|
|
