From 94a850dbd12df925e79e4aed1b0e1cdc9161134c Mon Sep 17 00:00:00 2001
From: zab <zab>
Date: Tue, 21 Oct 2003 18:18:51 +0000
Subject: [PATCH] - add the rprintf() that w_a_t.c has. - lots of general style
 cleanup - teach it to call 'od' to display the corrupt data on exit

---
 lustre/tests/write_disjoint.c | 147 +++++++++++++++++++++++++++---------------
 1 file changed, 94 insertions(+), 53 deletions(-)

diff --git a/lustre/tests/write_disjoint.c b/lustre/tests/write_disjoint.c
index 3ccb0e1..1969f3b 100644
--- a/lustre/tests/write_disjoint.c
+++ b/lustre/tests/write_disjoint.c
@@ -18,55 +18,75 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
+#include <string.h>
 #include <errno.h>
 #include <unistd.h>
+#include <stdarg.h>
 #include "mpi.h"
 
 
 #define FILENAME "/mnt/lustre/write_disjoint"
 #define CHUNK_MAX_SIZE 123456
 
+int rprintf(int rank, int loop, const char *fmt, ...)
+{
+        va_list       ap;
+ 
+        printf("rank %d, loop %d: ", rank, loop);
+ 
+        va_start(ap, fmt);
+ 
+        printf(fmt, ap);
+ 
+        MPI_Finalize();
+        exit(1);
+}
 
-int main( int argc,char *argv[] ) {
+int main (int argc, char *argv[]) {
          int i, n, fd, chunk_size, file_size;
-         int rank, noProcessors, ret, done;
+         int rank, noProcessors, done;
          off_t offset;
          char **chunk_buf;
          char *read_buf;
          struct stat stat_buf;
+         ssize_t ret;
 
          MPI_Init(&argc, &argv);
          MPI_Comm_size(MPI_COMM_WORLD, &noProcessors);
          MPI_Comm_rank(MPI_COMM_WORLD, &rank);
                          
-         chunk_buf = (char**)malloc(noProcessors * sizeof(void*));
-         for( i=0; i<noProcessors; i++) {
-                  chunk_buf[i] = (char*)malloc(CHUNK_MAX_SIZE);
-                 memset(chunk_buf[i], 'A'+ i, CHUNK_MAX_SIZE);
+         chunk_buf = malloc(noProcessors * sizeof(chunk_buf[0]));
+         for (i=0; i < noProcessors; i++) {
+                chunk_buf[i] = malloc(CHUNK_MAX_SIZE);
+                memset(chunk_buf[i], 'A'+ i, CHUNK_MAX_SIZE);
          }
-         read_buf = (char*)malloc(noProcessors * CHUNK_MAX_SIZE);
+         read_buf = malloc(noProcessors * CHUNK_MAX_SIZE);
          
-         if(rank == 0) {
-                  fd = open( FILENAME, O_WRONLY|O_CREAT|O_TRUNC, 0666);
-                 if(fd==0) 
-                         printf("open returned %s\n", strerror(errno) );
-                 close(fd);
+         if (rank == 0) {
+                fd = open(FILENAME, O_WRONLY|O_CREAT|O_TRUNC, 0666);
+                if (fd == 0) 
+                        rprintf(rank, -1, "open() returned %s\n", 
+                                strerror(errno));
          }
          MPI_Barrier(MPI_COMM_WORLD);
 
-         fd = open( FILENAME, O_RDWR);
-         if( fd==0 )
-                 printf("open returned %s\n", strerror(errno) );
+         fd = open(FILENAME, O_RDWR);
+         if (fd == 0)
+                 rprintf(rank, -1, "open() returned %s\n", strerror(errno));
          
-         for(n=0; n<1000; n++) {
+         for (n=0; n < 1000 ; n++) {
                  /* reset the environment */
-                 if(rank == 0) {
-                         ret = truncate( FILENAME, (off_t)0);
-                         if( ret!=0 )
-                                 printf("truncate returned %s\n", strerror(errno) );
+                 if (rank == 0) {
+                         ret = truncate(FILENAME, 0);
+                         if (ret != 0)
+                                 rprintf(rank, n, "truncate() returned %s\n", 
+                                         strerror(errno) );
                  }
                  chunk_size = rand() % CHUNK_MAX_SIZE;
 
+                 if (n % 1000 == 0 && rank == 0)
+                         printf("loop %d: chunk_size %d\n", n, chunk_size);
+
                  MPI_Barrier(MPI_COMM_WORLD);
                  
                  /* Do the race */
@@ -75,46 +95,67 @@ int main( int argc,char *argv[] ) {
 
                  done = 0;
                  do {
-                          ret = write(fd, chunk_buf[rank]+done, chunk_size-done);
-                         if( ret<0 ) {
-                                 printf("write returned %s\n", strerror(errno) );
-                                 break;
-                         }
-                         done += ret;
-                 } while( done != chunk_size );
+                        ret = write(fd, chunk_buf[rank]+done, chunk_size-done);
+                        if (ret < 0) 
+                                 rprintf(rank, n, "write() returned %s\n", 
+                                         strerror(errno));
+                        done += ret;
+                 } while (done != chunk_size);
 
                  MPI_Barrier(MPI_COMM_WORLD);
 
                  /* Check the result */
                  if (rank == 0) {
-                         lseek( fd, (off_t)0, SEEK_SET);
+                         lseek(fd, 0, SEEK_SET);
                          
                          /* quick check */
-                         stat( FILENAME, &stat_buf);
+                         stat(FILENAME, &stat_buf);
                          file_size = stat_buf.st_size;
-                         if(file_size != chunk_size*noProcessors) {
-                                  printf("Error(%d): invalid file size %d insteed of %d\n", n, file_size, chunk_size*noProcessors);
-                                 continue;
-                         }
-
-                         done = 0;
-                         do {
-                                 ret = read(fd, read_buf+done, chunk_size*noProcessors-done);
-                                 if( ret<0 ) {
-                                          printf("read returned %s\n", strerror(errno) );
-                                          break;
-                                 }
-                                 done += ret;
-                         } while( done!=chunk_size*noProcessors );
-                           for(i=0; i<noProcessors; i++) {
-                                 if( memcmp( read_buf+i*chunk_size, chunk_buf[i], chunk_size ) ) {
-                                        printf("Error(%d): chunk %d corrupted\n", n, i);
-                                 }
-                         }
-                 }
-         }
-         printf("Finished after %d loops\n", n);
+                         if (file_size != chunk_size * noProcessors)
+                                  rprintf(rank, n, "invalid file size %d"
+                                          " instead of %d\n", file_size, 
+                                          chunk_size * noProcessors);
+
+                        done = 0;
+                        do {
+                                ret = read(fd, read_buf + done, 
+                                           (chunk_size * noProcessors) - done);
+                                if (ret < 0) 
+                                        rprintf(rank, n, "read returned %s\n",
+                                                strerror(errno));
+
+                                done += ret;
+                        } while (done != chunk_size * noProcessors);
+
+                        for (i = 0; i < noProcessors; i++) {
+                                char command[4096]; 
+                                int j;
+                                if (!memcmp(read_buf + (i * chunk_size), 
+                                           chunk_buf[i], chunk_size))
+                                        continue;
+
+                                printf("rank %d, loop %d: chunk %d corrupted "
+                                       "with chunk_size %d\n", rank, n, i, 
+                                       chunk_size);
+                                printf("(ranks: page boundry, chunk boundry, "
+                                       "page boundry)\n");
+                                for (j = 1 ; j < noProcessors; j++) {
+                                        int b = j * chunk_size;
+                                        printf("\t%c -> %c: %d %d %d\n", 
+                                               'A' + j - 1, 'A' + j, 
+                                               b & ~(4096-1), b, 
+                                               (b + 4096) & ~(4096-1));
+                                }
+
+                                sprintf(command, "od -Ad -a %s", FILENAME);
+                                system(command);
+                                MPI_Finalize();
+                                exit(1);
+                        }
+                }
+        }
 
-         MPI_Finalize();
-         return 0;
+        printf("Finished after %d loops\n", n);
+        MPI_Finalize();
+        return 0;
 }
-- 
1.8.3.1