Dear all,

I'm working on a C++ application in Slackware 10.0. Because of a non-reentrant library I'm using in this project I switched from pthreads to forked processes. However I'm not really sure how to handle file output. Each child has a list of jobs. For each job it does some work and dumps the results (as two lines of text) in the same text file. So each child opens, writes and closes that same file many times. I use the fstream library for this purpose. When I was using pthreads, each thread tried to obtain a defined mutex lock and if succesfull, it could write its results to the file.

Should I implement a similar locking mechanism (flock() I believe it's called) when using forked processes? At the moment I'm using no locking at all and everything seems to work just fine. I'm I just being lucky or is this normal? If this is normal, would it be possible for each child to just keep the file open all the time and write to it when a job is finished? This would avoid the iterative file opening and closing and would therefore be more efficient. However, it would require some sort of queuing mechanism from the kernel as it would be really bad if the output of one child gets mangled up with the output of another child.

Could anybody shed some light on these matters?

thank you and friendly regards,

Steven

I believe you are safe as long as you are appending to the files.

As the EOF pointer is the same for each fork'd file descriptor, and each
is updated (I think atomically) with an append.

random access wil be unsafe though.

I'd recommend doing a an explicit lock just to be safe.
If you've only got a small num of processes and they write a small amt of data, you can get away with it, but it's not recommended. It's also possible (I think) you'll get interleaved results.

If you open the file in append mode (also requires reading mode,) all output will be written to the end regardless of how many processes are writing to the file. Without the append flag, though, that's not guaranteed.

Do the line pairs have to stay together in the file? If so, you should either use a file lock or switch the output buffer mode to "fully-buffered" with setvbuf and flush the buffer after outputting each pair of lines. Write operations are implicitly locking (in other words, they lock out writing by other processes,) so if output is fully-buffered then all output is written at once when you flush the buffer. It will probably be line-buffered by default, which means it will write every time a newline is output, allowing for the remote possibility of line pairs not showing up together.

Keep in mind that file locks aren't mandatory unless the file system is mounted with the mand option (for mandatory locks) and the file has certain flags set (setgid without group-execute.) You can't count on that, so your processes all need to honor a mutex-style locking system. I'd use fcntl to remain Unix-portable for file locks if you're going to use them.
ta0kira