Sharing a file among two or more processes may be hazardous.
When a file is being shared among two or more processes and is being
written to by one or more of them, care must be taken to ensure
that the processes are properly interlocked. For example, if process
A is trying to read a particular record of the file, and at that
time process B should execute and try to write that record, the
results are not predictable. process A may see the old record or the
new record, and not know whether it has read good data. If buffering
is being done, please bear in mind that an output request (FWRITE)
does not cause physical I/O to occur until a
block is filled, which typically contains several records. A process
trying to read such a file could, for example, read past the last
record of the file which has been written on the disk because the
end-of-file pointer is not kept in the file, but is kept in core
where it can be updated quickly as writes occur. The necessary interlocking
is provided by the intrinsics FLOCK and FUNLOCK, which use
a resource identification number (RIN)
as a flag to interlock multiple accessors.
In the simple case of a file shared between a writer process
and a reader process, where the writer is merely adding records
to the file, the writer calls FLOCK prior to writing each record and
FUNLOCK after writing. The reader calls FLOCK prior to
reading each record, and FUNLOCK after reading. If the writing process
should execute while the reader is in the middle of a read, the writer will be
impeded on its FLOCK call until the reader signals that it is done
by calling FUNLOCK. Similarly, if the reader should execute while
the writer is performing a write, the reader will be impeded on
its FLOCK call until the writer calls FUNLOCK.
FUNLOCK ensures that all buffers are posted on the disk
so that the reading processes can see all of the data.
More complicated cases arise when a file has two or more writing
processes, or when the writer may write more than one record at
a time. If, for example, it should be necessary to write pairs of
records, with read prohibited until both records of the pair are
written, the writing process can call FLOCK before writing the first
record of the pair, and FUNLOCK after writing the second.
The shared file management scheme that MPE/iX provides you through the use of
the FLOCK and FUNLOCK intrinsics guarantees you exclusive
access to a file being shared by a set of processes that may be located in
different jobs or sessions. MPE/iX also provides you with RINs you
can use to manage anything you may consider a resource to your program, be
it portions of a file, a device, or a segment of code in your program.
Managing shared resources with RINs is described in Resource
Management Programmer's Guide.
For more information about the FLOCK and FUNLOCK intrinsics,
consult the MPE/iX Intrinsics Reference Manual.