FCOPY File copy implemented by memory mapped files.
Description
-----------
This program demonstrates how to use file mappings to implement a file-copy
program. It specifcally shows you how to use the following Win32 APIs to
implement code that maps files into memory:
CreateFile
CreateFileMapping
MapViewOfFile
UnmapViewOfFile
CloseHandle
Accessing Files Through File Mappings
-------------------------------------
In a nutshell, file mappings allow processes to create a region of virtual
memory that is backed by a specific file rather than the system pagefile.
The contents of the region can be paged in and out on demand just like any
other vitual memory, but will alway be paged in or out of the file being
mapped. The process that created/opened the mapping uses pointers to this
region to access the file's data, just as it would use pointers to access a
block of dynamically-allocated memory.
File mappings can be used for two purposes:
1) Accessing a file's contents as though it were memory
2) Sharing memory between processes
This sample shows an application of purpose #1.
Why would you use file mappings to access files? It may be easier to treat
a file's contents as memory (the Windows NT loader uses file mappings to load
executables, DLLs, and device drivers this way), or it may require less work
than conventional file I/O, which includes (to update an item in a file):
Opening the file
Allocating memory for the file's contents
Seeking to the right place in the file
Reading the file's contents into memory
Modifying the memory
Seeking back to where the file's contents should be written
Writing it back out
Closing the file
Freeing the allocated memory
With file mappings, you can do the same with just:
Open the file
Create a mapping
Map a view of the portion of the file needed
Modify the contents through the view directly
Unmap the view
Close the mapping
Close the file
Depending on how many separate places you have to update in the file, file
mappings can save a huge amount of seeking from place to place, and from
having to allocate and manage memory.
File Mapping Notes
------------------
When using file mappings to access a file's contents, be aware of the
following issues:
1) If you create a mapping of a file that is larger than the file
currently is, the file will be grown. If the file cannot be grown, your
request to create a mapping (i.e. call to CreateFileMapping) will fail.
One reason that a file cannot be grown is if the file is read-only;
another is that on Windows NT, you may not have permission to write to
the file.
2) Once a file mapping is created, it cannot be resized. You have to
close the mapping and create a new one.
3) You can close a mapping before unmapping the views, or vice-versa.
As long as there are open views, the mapping object will not be
destroyed even if the mapping handle is closed. This is because
each view of a mapping refers to the mapping object, thereby keeping
the object's reference count above zero.
4) The corrollary to #3 is that in order to clean up a file mapping,
you must unmap all of the views and close all handles to the file
mapping object. Failure to do so is a leak.
How to Build FCOPY
-------------------
Debug build:
nmake
Release build:
nmake "nodebug =1"
How to Execute FCOPY
--------------------
FCOPY runs on Windows NT and Windows 95 and Windows 98.
Run FCOPY from the command line and specify a source filename followed by a
destination filename. For example:
c:>fcopy important.txt backup.txt
