Understand concurrent file writing from multiple processes

#include 
#include  
#include 
#include 
#include 
#include 
 #include 

int 
main(int argc, char** argv) {
 int rank, size, i, bufsize = 134217728, fd, status = 0, bytes_written, tmp_bytes_written;
 int* buf;
 char* filename = "/tmp/testfile.out";
 MPI_Init(&argc, &argv);
 MPI_Comm_rank(MPI_COMM_WORLD, &rank);
 MPI_Comm_size(MPI_COMM_WORLD, &size);
 buf = (int*) malloc (bufsize * sizeof(int)); 
 if( buf == NULL) {
 status = -1;
 perror("Could not malloc");
 goto finalize;
 }
 for(i=0; i buf[i] = rank;

 if(-1 == (fd = open(filename, O_APPEND|O_WRONLY, S_IWUSR))) {
 perror("Cant open file");
 status = -1;
 goto end;
 exit(-1);
 }
 bytes_written = 0;
 if(bufsize != (tmp_bytes_written = write(fd, buf, bufsize)) ) {
 perror("Error during write");
 printf("ret value: %d

", tmp_bytes_written);
 status = -1;
 goto close; 
 }
close:
 if(-1 == close(fd)) {
 perror("Error during close");
 status = -1;
 }
end:
 free(buf);
finalize:
 MPI_Finalize();
 return status;
}< /pre> 

From here: Is file append atomic in UNIX

Consider the situation where multiple processes open the same file and append to it. O_APPEND guarantees that it is atomic to find the end of the file and then start the write operation. Therefore, as long as each write The input size is <= PIPE_BUF, multiple processes can be attached to the same file, and any process will not overwrite the writing of any other process. I wrote a test program in which multiple processes open and write to the same File(write(2)). I made sure that each write size is> PIPE_BUF(4k). I expected to see instances where the process overwrites other people’s data. But that didn’t happen. I tested different write sizes. Is it just luck or is there a reason not to?
My ultimate goal is to understand whether multiple processes attached to the same file need to coordinate their writes.

This is the complete plan. Each process creates an int buffer and ranks it with Fill in all the values, open a file and write to it.

Glasses:
OpenMPI 1.4.3 on
Open 11.3 64-bit

Compiled to: mpicc -O3 test .c,
Run mode: mpirun -np 8 ./a.out

#include 
#include  
#include 
#include 
#include 
#include 
 #include 

int 
main(int argc, char** argv) {
 int rank, size, i, bufsize = 134217728, fd, status = 0, bytes_written, tmp_bytes_written;
 int* buf;
 char* filename = "/tmp/testfile.out";
 MPI_Init(&argc, &argv);
 MPI_Comm_rank(MPI_COMM_WORLD, &rank);
 MPI_Comm_size(MPI_COMM_WORLD, &size);
 buf = (int*) malloc (bufsize * sizeof(int)); 
 if( buf == NULL) {
 status = -1;
 perror("Could not malloc");
 goto finalize;
 }
 for(i=0; i buf[i] = rank;
 if(-1 == (fd = open(filename, O_APPEND|O_WRONLY, S_IWUSR))) {
 perror("Cant open file");
 status = -1;
 goto end ;
 exit(-1);
 }
 bytes_written = 0;
 if(bufsize != (tmp_bytes_written = write(fd, buf, bufsize))) {
 perror("Error during write");
 printf("ret value: %d

", tmp_bytes_written);
 status = -1;
 goto close;< br /> }
close:
 if(-1 == close(fd)) {
 perror("Error during close");
 status =- 1;
 }
end:
 free(buf);
finalize:
 MPI_Finalize();
 return status;
}

The atomicity of writing less than PIPE_BUF only applies to pipes and FIFOs. For file writing, POSIX says: 
 

This volume of POSIX.1-2008 does not specify behavior of concurrent
 writes to a file from multiple processes. Applications should use some
 form of concurrency control.
 < /blockquote> 
...This means yourself – different UNIX likes will provide no Same guarantee.