Changeset 113

Show
Ignore:
Timestamp:
03/20/07 18:11:40
Author:
apokayi
Message:

added the list_shared_async verifications
Kun : data integrity is violated we should check this

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • src/io_fread_list_shared_async_comm.upc

    r103 r113  
    1313#endif 
    1414 
     15static TYPE vbf[180]; 
    1516 
    1617/* nmembs and offsets, this only works for up to 8 threads */ 
    …… 
    2526        upc_off_t offset = offsets[MYTHREAD]; 
    2627        int blocksize = BLOCKSIZE; 
     28        TYPE *vbfp; 
    2729        ssize_t bytes; 
    2830 
    2931#if BLOCKSIZE != 0 
    30         shared [BLOCKSIZE] TYPE *buffer = (shared[BLOCKSIZE] TYPE*) upc_all_alloc(100, blocksize*sizeof(TYPE)); 
     32        shared [BLOCKSIZE] TYPE *buffer = (shared[BLOCKSIZE] TYPE*) upc_all_alloc(180, blocksize*sizeof(TYPE)); 
    3133#endif 
     34        struct upc_shared_memvec  memvec[2]; 
     35        memvec[0].baseaddr = buffer + offsets[0]; 
     36        memvec[0].blocksize = blocksize; 
     37        memvec[0].len = nmembs[0]; 
     38        memvec[0].elemsize = sizeof(TYPE); 
    3239 
    33 struct upc_shared_memvec  memvec[2]; 
    34         memvec[0].baseaddr = buffer + offsets[0]; 
    35         memvec[0].blocksize = blocksize; 
    36         memvec[0].elemsize = 4; 
    37         memvec[0].len = nmembs[0]; 
     40        memvec[1].baseaddr = buffer + offsets[1]; 
     41        memvec[1].blocksize = blocksize; 
     42        memvec[1].len = nmembs[1]; 
     43        memvec[1].elemsize = sizeof(TYPE); 
    3844 
    39         memvec[1].baseaddr = buffer + offsets[1]; 
    40         memvec[1].blocksize = blocksize; 
    41         memvec[1].len = nmembs[1]; 
    42         memvec[1].elemsize = 4; 
     45        struct upc_filevec filevec[3]; 
     46        filevec[0].offset = offsets[0] * sizeof(TYPE); 
     47        filevec[0].len = 30 * sizeof(TYPE); 
    4348 
    44         struct upc_filevec filevec[3]; 
    45         filevec[0].offset = offsets[0]*4; 
    46         filevec[0].len = 30*4; 
     49        filevec[1].offset = offsets[1] * sizeof(TYPE); 
     50        filevec[1].len = 1 * sizeof(TYPE); 
    4751 
    48         filevec[1].offset = offsets[1]*4; 
    49         filevec[1].len = 1*4; 
    50  
    51         filevec[2].offset = 40*4; 
    52         filevec[2].len = 29*4; 
    53  
    54         for( j = 0; j< THREADS; j++ ) { 
    55                 if( MYTHREAD == j) { 
    56                         fprintf(stderr, "TH%d : ", j); 
    57                         for(i = 0; i < 2; i++ ) 
    58                                 fprintf( stderr, "memvec: len = %d, fv: offset = %d\n", memvec[i].len, filevec[i].offset ); 
    59                         fprintf(stderr, "\n"); 
    60                 } 
    61                 sleep(3); 
    62                 upc_barrier; 
    63         } 
     52        filevec[2].offset = 40 * sizeof(TYPE); 
     53        filevec[2].len = 29 * sizeof(TYPE); 
    6454 
    6555        upc_file_t* fd = upc_all_fopen(argv[1], UPC_RDONLY | UPC_COMMON_FP, 0, NULL); 
    …… 
    6757#if BLOCKSIZE != 0 
    6858                if (MYTHREAD == 0) 
    69                 upc_free(buffer); 
     59                       upc_free(buffer); 
    7060#endif 
    7161                GULA_FAIL("failed to open the file using UPC_RDONLY | UPC_COMMON_FP"); 
    …… 
    7565        upc_all_fread_list_shared_async(fd, 2, memvec, 1, filevec, UPC_IN_NOSYNC | UPC_OUT_NOSYNC); 
    7666        bytes = upc_all_fwait_async(fd); 
    77         offset = upc_all_fseek(fd, 0, UPC_SEEK_CUR); 
    7867        upc_barrier; 
    7968 
    80         if( MYTHREAD == 0) { 
    81                 fprintf(stderr, "TH%d : ", MYTHREAD); 
    82                 for(i = 0; i < nmembs[0]; i++ ) 
    83                         fprintf( stderr, "%u ", buffer[ i+offsets[0] ] ); 
    84                 fprintf(stderr, "\n\n\n"); 
     69        /* Validation start */ 
    8570 
    86                 fprintf(stderr, "TH%d : ", MYTHREAD); 
    87                 for(i = 0; i < nmembs[1]; i++ ) 
    88                         fprintf( stderr, "%u ", buffer[ i+offsets[1] ] ); 
    89                 fprintf(stderr, "\n"); 
    90         } 
    91         offset = upc_all_fseek(fd, 0, UPC_SEEK_CUR); 
    92         fprintf(stderr, "Th%d: origin=%d, read %d bytes, cur offset = %d\n", MYTHREAD, 0, bytes, offset); 
    93         upc_barrier; 
     71        /* copy the chunks to vbf */ 
     72        vbfp = vbf; 
     73        gupc_memget(vbfp, memvec[0].baseaddr, blocksize, sizeof(TYPE), memvec[0].len); 
     74        vbfp += memvec[0].len; 
     75        gupc_memget(vbfp, memvec[1].baseaddr, blocksize, sizeof(TYPE), memvec[1].len); 
     76 
     77        /* verify the data using the filevec information */ 
     78        vbfp = vbf; 
     79        for (i = 0; i < 3; i++) { 
     80                for (j = 0; j < filevec[i].len/sizeof(TYPE); j++) { 
     81                        if (*vbfp != (filevec[i].offset / sizeof(TYPE) + j) % 0x80) 
     82                                GULA_FAIL("Data integrity is violated!"); 
     83                        vbfp ++; 
     84                } 
     85        } 
    9486 
    9587#if BLOCKSIZE != 0         

  • src/io_fread_list_shared_async_ind.upc

    r103 r113  
    1414#endif 
    1515 
     16static TYPE vbf[180]; 
    1617 
    17 /* nmembs and offsets, this only works for up to 8 threads */ 
    18 static int nmembs [] = { 23, 37, 12 , 44, 14, 31, 4, 55}; 
    19 static int offsets [] = { 2, 30, 81 , 25, 77, 121, 139, 47}; 
     18/* nmembs and offsets, this only works for up to 6 threads */ 
     19static int nmembs [] = { 23, 2, 37, 5, 41, 7}; 
     20static int offsets [] = { 2, 130, 30, 140, 77, 150}; 
    2021 
    2122int 
    …… 
    2627        int offset = offsets[MYTHREAD]; 
    2728        int blocksize = BLOCKSIZE;               
    28         ssize_t bytes; 
     29        TYPE *vbfp; 
    2930         
    3031#if BLOCKSIZE != 0 
    31         shared [BLOCKSIZE] TYPE *buffer = (shared[BLOCKSIZE] TYPE*) upc_all_alloc(100, blocksize*sizeof(TYPE)); 
     32        shared [BLOCKSIZE] TYPE *buffer = (shared[BLOCKSIZE] TYPE*) upc_all_alloc(180, blocksize*sizeof(TYPE)); 
    3233#endif 
     34         
     35        struct upc_shared_memvec  memvec[2]; 
     36        memvec[0].baseaddr = buffer + offsets[MYTHREAD * 2]; 
     37        memvec[0].blocksize = blocksize; 
     38        memvec[0].len = nmembs[MYTHREAD * 2]; 
     39        memvec[0].elemsize = sizeof(TYPE); 
    3340 
    34 struct upc_shared_memvec  memvec[2]; 
    35         memvec[0].baseaddr = buffer + offsets[MYTHREAD]; 
    36         memvec[0].blocksize = blocksize; 
    37         memvec[0].len = nmembs[MYTHREAD]; 
    38         memvec[0].elemsize = 4; 
     41        memvec[1].baseaddr = buffer + offsets[MYTHREAD * 2 + 1]; 
     42        memvec[1].blocksize = blocksize; 
     43        memvec[1].len = nmembs[MYTHREAD * 2 + 1]; 
     44        memvec[1].elemsize = sizeof(TYPE); 
    3945 
    40         memvec[1].baseaddr = buffer + offsets[MYTHREAD+THREADS]; 
    41         memvec[1].blocksize = blocksize; 
    42         memvec[1].len = nmembs[MYTHREAD+THREADS]; 
    43         memvec[1].elemsize = 4; 
    44  
    45         struct upc_filevec filevec[3]; 
    46         filevec[0].offset = offsets[MYTHREAD]*4; 
    47         filevec[0].len = 10*4; 
    48         filevec[1].offset = offsets[MYTHREAD+1]*4; 
    49         filevec[1].len = 10*4; 
    50         filevec[2].offset = offsets[MYTHREAD+2]*4; 
    51         filevec[2].len = 4*(nmembs[MYTHREAD] + nmembs[MYTHREAD+THREADS] - 20); 
    52  
    53         for( j = 0; j< THREADS; j++ ) { 
    54                 if( MYTHREAD == j) { 
    55                         fprintf(stderr, "TH%d : ", j); 
    56                         for(i = 0; i < 2; i++ ) 
    57                                 fprintf( stderr, "memvec: len = %d, fv: offset = %d\n", memvec[i].len, filevec[i].offset ); 
    58                         fprintf(stderr, "\n"); 
    59                 } 
    60                 upc_barrier; 
    61         } 
     46        struct upc_filevec filevec[3]; 
     47        filevec[0].offset = offsets[MYTHREAD] * sizeof(TYPE); 
     48        filevec[0].len = 10 * sizeof(TYPE); 
     49        filevec[1].offset = offsets[MYTHREAD+1] * sizeof(TYPE); 
     50        filevec[1].len = 10 * sizeof(TYPE); 
     51        filevec[2].offset = offsets[MYTHREAD+2] * sizeof(TYPE); 
     52        filevec[2].len = (memvec[0].len + memvec[1].len - 20) * sizeof(TYPE); 
    6253 
    6354        upc_file_t* fd = upc_all_fopen(argv[1], UPC_RDONLY | UPC_INDIVIDUAL_FP, 0, NULL); 
    …… 
    6556#if BLOCKSIZE != 0 
    6657                if (MYTHREAD == 0) 
    67                 upc_free(buffer); 
     58                       upc_free(buffer); 
    6859#endif 
    6960                GULA_FAIL("failed to open the file using UPC_RDONLY | UPC_INDIVIDUAL_FP"); 
    7061        } 
    7162        upc_barrier; 
     63         
    7264        upc_all_fread_list_shared_async(fd, 2, memvec, 3, filevec, UPC_IN_NOSYNC | UPC_OUT_NOSYNC); 
    73         bytes = upc_all_fwait_async(fd); 
    74         offset = upc_all_fseek(fd, 0, UPC_SEEK_CUR); 
    75          
    7665        upc_barrier; 
    7766 
    78         for( j = 0; j< THREADS; j++ ) { 
    79                 if( MYTHREAD == j) { 
    80                         fprintf(stderr, "TH%d : ", j); 
    81                         for(i = 0; i < nmembs[MYTHREAD]; i++ ) 
    82                                 fprintf( stderr, "%u ",  buffer[ i+offsets[MYTHREAD] ] ); 
    83                         fprintf(stderr, "\n"); 
     67        /* Validation start */ 
    8468 
    85                         fprintf(stderr, "TH%d : ", j); 
    86                         for(i = 0; i < nmembs[THREADS+MYTHREAD]; i++ ) 
    87                                 fprintf( stderr, "%u ",  buffer[ i+offsets[THREADS+MYTHREAD] ] ); 
    88                         fprintf(stderr, "\n"); 
    89                 } 
    90                 upc_barrier; 
    91         } 
     69        /* copy the chunks to vbf */ 
     70        vbfp = vbf; 
     71        gupc_memget(vbfp, memvec[0].baseaddr, blocksize, sizeof(TYPE), memvec[0].len); 
     72        vbfp += memvec[0].len; 
     73        gupc_memget(vbfp, memvec[1].baseaddr, blocksize, sizeof(TYPE), memvec[1].len); 
     74 
     75        /* verify the data using the filevec information */ 
     76        vbfp = vbf; 
     77        for (i = 0; i < 3; i++) { 
     78                for (j = 0; j < filevec[i].len/sizeof(TYPE); j++) { 
     79                        if (*vbfp != (filevec[i].offset / sizeof(TYPE) + j) % 0x80) 
     80                                GULA_FAIL("Data integrity is violated!"); 
     81                        vbfp ++; 
     82                } 
     83        } 
    9284 
    9385#if BLOCKSIZE != 0         

  • src/io_fwrite_list_shared_async_comm.upc

    r103 r113  
    1313#endif 
    1414 
     15shared [0] TYPE vbf[180]; 
     16 
    1517/* nmembs and offsets, this only works for up to 8 threads */ 
    16 static int nmembs [] = { 23, 37, 12 , 44, 14, 31, 4, 55}; 
    17 static int offsets [] = { 2, 30, 81 , 25, 77, 121, 139, 47}; 
     18static int nmembs [] = { 23, 37}; 
     19static int offsets [] = { 2, 35}; 
    1820 
    1921int 
    …… 
    2123 
    2224        int i, j; 
    23         int nmemb = nmembs[MYTHREAD]; 
    24         upc_off_t offset = offsets[MYTHREAD]; 
    2525        int blocksize = BLOCKSIZE; 
     26        ssize_t ret, bytes; 
     27        shared [0] TYPE *vbfp; 
    2628 
    2729#if BLOCKSIZE != 0 
    28         shared [BLOCKSIZE] TYPE *buffer = (shared[BLOCKSIZE] TYPE*) upc_all_alloc(100, blocksize*sizeof(TYPE)); 
     30        shared [BLOCKSIZE] TYPE *buffer = (shared[BLOCKSIZE] TYPE*) upc_all_alloc(180, blocksize*sizeof(TYPE)); 
    2931#endif 
    3032 
    31         if( MYTHREAD == 0) { 
    32                 for(i=0;  i< 100; i++) 
    33                         buffer[i] = i% 256; 
    34         } 
     33        struct upc_shared_memvec  memvec[2]; 
     34        memvec[0].baseaddr = buffer + offsets[0]; 
     35        memvec[0].blocksize = blocksize; 
     36        memvec[0].len = nmembs[0]; 
     37        memvec[0].elemsize = sizeof(TYPE); 
    3538 
    36         struct upc_shared_memvec  memvec[2]; 
    37         memvec[0].baseaddr = buffer + offsets[0]; 
    38         memvec[0].blocksize = blocksize; 
    39         memvec[0].len = nmembs[0]; 
    40         memvec[0].elemsize = 1; 
     39        memvec[1].baseaddr = buffer + offsets[1]; 
     40        memvec[1].blocksize = blocksize; 
     41        memvec[1].len = nmembs[1]; 
     42        memvec[1].elemsize = sizeof(TYPE); 
    4143 
    42         memvec[1].baseaddr = buffer + offsets[1]; 
    43         memvec[1].blocksize = blocksize; 
    44         memvec[1].len = nmembs[1]; 
    45         memvec[1].elemsize = 1; 
     44        struct upc_filevec filevec[3]; 
     45        filevec[0].offset = offsets[0] * sizeof(TYPE); 
     46        filevec[0].len = 30 * sizeof(TYPE); 
    4647 
    47         struct upc_filevec filevec[3]; 
    48         filevec[0].offset = offsets[0]; 
    49         filevec[0].len = 30; 
     48        filevec[1].offset = offsets[1] * sizeof(TYPE); 
     49        filevec[1].len = 1 * sizeof(TYPE); 
    5050 
    51        filevec[1].offset = offsets[1]; 
    52        filevec[1].len = 1; 
     51        filevec[2].offset = 40 * sizeof(TYPE); 
     52        filevec[2].len = 29 * sizeof(TYPE); 
    5353 
    54         filevec[2].offset = 40; 
    55         filevec[2].len = 29; 
     54        if( MYTHREAD == 0) 
     55                for( i = 0; i< 180; i++ ) 
     56                        buffer[i] = i % 0x80; 
     57        upc_barrier; 
    5658 
    57  
    58         for( j = 0; j< THREADS; j++ ) { 
    59                 if( MYTHREAD == j) { 
    60                         fprintf(stderr, "TH%d : ", j); 
    61                         for(i = 0; i < 2; i++ ) 
    62                                 fprintf( stderr, "memvec: len = %d, fv: offset = %d\n", memvec[i].len, filevec[i].offset ); 
    63                         fprintf(stderr, "\n"); 
    64                 } 
    65                 sleep(3); 
    66                 upc_barrier; 
    67         } 
    68  
    69         upc_file_t* fd = upc_all_fopen("write_test.txt", UPC_WRONLY | UPC_COMMON_FP, 0, NULL); 
     59        upc_file_t* fd = upc_all_fopen("write_test.txt", UPC_RDWR | UPC_CREATE | UPC_TRUNC | UPC_COMMON_FP, 0, NULL); 
    7060        if (fd == NULL) { 
    7161#if BLOCKSIZE != 0 
    …… 
    7363                        upc_free(buffer); 
    7464#endif 
    75                 GULA_FAIL("failed to open the file using UPC_WRONLY | UPC_COMMON_FP"); 
     65                GULA_FAIL("failed to open the file using UPC_RDWR | UPC_COMMON_FP"); 
    7666        } 
    7767        upc_barrier; 
    …… 
    7969        upc_all_fwrite_list_shared_async(fd, 2, memvec, 3, filevec, UPC_IN_NOSYNC | UPC_OUT_NOSYNC); 
    8070        ssize_t bytes = upc_all_fwait_async(fd); 
    81         upc_off_t vo = upc_all_fseek(fd, 0, UPC_SEEK_CUR); 
    82         fprintf(stderr, "th%d: origin = 0 wrtie %d bytes, offset = %d \n", MYTHREAD, bytes, vo); 
     71        upc_barrier; 
     72         
     73        /* Validation for data integirty */ 
     74        /* Read the data to vbf */ 
     75        vbfp = vbf;  
     76        for (i = 0; i < 3; i++) {  
     77                upc_all_fseek(fd, filevec[i].offset, UPC_SEEK_SET); 
     78                ret = upc_all_fread_shared(fd, vbfp, 0, sizeof(TYPE), filevec[i].len/sizeof(TYPE), UPC_IN_NOSYNC | UPC_OUT_NOSYNC); 
     79                vbfp += filevec[i].len / sizeof(TYPE); 
     80                upc_barrier; 
     81        } 
     82         
     83        /* Check the data integrity based on the memvec */ 
     84        vbfp = vbf;  
     85        for (i = 0; i < 2; i++) { 
     86                for (j = 0; j < memvec[i].len; j++) {  
     87                        if (*vbfp != (offsets[i] + j) % 0x80)    
     88                                GULA_FAIL("Data integrity is violated!"); 
     89                        vbfp ++; 
     90                } 
     91        } 
     92        upc_barrier; 
    8393 
    8494#if BLOCKSIZE != 0         

  • src/io_fwrite_list_shared_async_ind.upc

    r103 r113  
    1414#endif 
    1515 
     16static TYPE vbf[180]; 
    1617 
    17 /* nmembs and offsets, this only works for up to 8 threads */ 
    18 static int nmembs [] = { 23, 37, 12 , 44, 14, 31, 4, 55}; 
    19 static int offsets [] = { 2, 30, 81 , 25, 77, 121, 139, 47}; 
    20 static int foffs[] = { 0, 30,  90, 11, 45, 110, 22, 57, 133 }; 
     18/* nmembs and offsets, this only works for up to 3 threads */ 
     19/* Please consider the overlapping for list operation */ 
     20 
     21static int nmembs [] = { 23, 2, 37, 5, 41, 7}; 
     22static int offsets [] = { 0, 130, 26, 140, 77, 150}; 
     23static int foffs[] = { 0, 11, 22, 30, 45, 57, 90, 110, 133}; 
    2124 
    2225int 
    …… 
    2427 
    2528        int i, j; 
    26         int nmemb = nmembs[MYTHREAD]; 
    27         upc_off_t offset = offsets[MYTHREAD]; 
    2829        int blocksize = BLOCKSIZE; 
     30        TYPE *vbfp; 
    2931 
    3032#if BLOCKSIZE != 0 
    31         shared [BLOCKSIZE] TYPE *buffer = (shared[BLOCKSIZE] TYPE*) upc_all_alloc(200, blocksize*sizeof(TYPE)); 
     33        shared [BLOCKSIZE] TYPE *buffer = (shared[BLOCKSIZE] TYPE*) upc_all_alloc(180, blocksize*sizeof(TYPE)); 
    3234#endif 
    3335 
    3436        if(MYTHREAD == 0) { 
    35                 for(i = 0; i< 200; i++)        
    36                         buffer[i]  = i % 256; 
     37                for(i = 0; i< 180; i++)        
     38                        buffer[i]  = i % 0x80; 
    3739        } 
    3840        upc_barrier; 
    3941 
    4042        struct upc_shared_memvec  memvec[2]; 
    41        memvec[0].baseaddr = buffer + offsets[MYTHREAD]; 
    42        memvec[0].blocksize = blocksize; 
    43        memvec[0].len = nmembs[MYTHREAD]; 
    44        memvec[0].elemsize = 1; 
     43        memvec[0].baseaddr = buffer + offsets[MYTHREAD * 2]; 
     44        memvec[0].blocksize = blocksize; 
     45        memvec[0].len = nmembs[MYTHREAD * 2]; 
     46        memvec[0].elemsize = sizeof(TYPE); 
    4547 
    46        memvec[1].baseaddr = buffer + offsets[MYTHREAD+THREADS]; 
    47        memvec[1].blocksize = blocksize; 
    48        memvec[1].len = nmembs[MYTHREAD+THREADS]; 
    49        memvec[1].elemsize = 1; 
     48        memvec[1].baseaddr = buffer + offsets[MYTHREAD * 2 + 1]; 
     49        memvec[1].blocksize = blocksize; 
     50        memvec[1].len = nmembs[MYTHREAD * 2 + 1]; 
     51        memvec[1].elemsize = sizeof(TYPE); 
    5052 
    51         struct upc_filevec filevec[3]; 
    52         filevec[0].offset = foffs[MYTHREAD]; 
    53         filevec[0].len = 10; 
     53        struct upc_filevec filevec[3]; 
     54        filevec[0].offset = foffs[MYTHREAD * 3] * sizeof(TYPE); 
     55        filevec[0].len = 10 * sizeof(TYPE); 
     56        filevec[1].offset = foffs[MYTHREAD * 3 + 1] * sizeof(TYPE); 
     57        filevec[1].len = 10 * sizeof(TYPE); 
     58        filevec[2].offset = foffs[MYTHREAD * 3 + 2] * sizeof(TYPE); 
     59        filevec[2].len = (memvec[0].len + memvec[1].len - 20) * sizeof(TYPE); 
    5460 
    55         filevec[1].offset = foffs[MYTHREAD+THREADS]; 
    56         filevec[1].len = 10; 
    57  
    58         filevec[2].offset = foffs[MYTHREAD+THREADS*2]; 
    59         filevec[2].len = nmembs[MYTHREAD] + nmembs[MYTHREAD+THREADS]-20; 
    60  
    61         for( j = 0; j< THREADS; j++ ) { 
    62                 if( MYTHREAD == j) { 
    63                         fprintf(stderr, "TH%d : ", j); 
    64                         for(i = 0; i < 2; i++ ) 
    65                                 fprintf( stderr, "memvec: len = %d, fv: offset = %d\n", memvec[i].len, filevec[i].offset ); 
    66                         fprintf(stderr, "\n"); 
    67                 } 
    68                 upc_barrier; 
    69         } 
    70  
    71         upc_file_t* fd = upc_all_fopen("write_test.txt", UPC_WRONLY | UPC_INDIVIDUAL_FP, 0, NULL); 
     61        upc_file_t* fd = upc_all_fopen("write_test.txt", UPC_RDWR | UPC_CREATE | UPC_TRUNC | UPC_INDIVIDUAL_FP, 0, NULL); 
    7262        if (fd == NULL) { 
    7363#if BLOCKSIZE != 0 
    …… 
    7565                        upc_free(buffer); 
    7666#endif 
    77                 GULA_FAIL("failed to open the file using UPC_WRONLY | UPC_INDIVIDUAL_FP"); 
     67                GULA_FAIL("failed to open the file using UPC_RDWR | UPC_INDIVIDUAL_FP"); 
    7868        } 
    7969        upc_barrier; 
    8070         
    8171        upc_all_fwrite_list_shared_async(fd, 2, memvec, 3, filevec, UPC_IN_NOSYNC | UPC_OUT_NOSYNC); 
    82         fprintf(stderr, "finish writing Th%d \n", MYTHREAD); 
    83         ssize_t bytes = upc_all_fwait_async(fd); 
    84         upc_off_t vo = upc_all_fseek(fd, 0, UPC_SEEK_CUR); 
    85         fprintf(stderr, "th%d: origin = 0 write %d bytes, offset = %d \n", MYTHREAD, bytes, vo); 
    8672        upc_barrier; 
     73 
     74        /* Validation for data integirty */ 
     75        /* Read the data to vbf */ 
     76        vbfp = vbf; 
     77        for (i = 0; i < 3; i++) { 
     78                upc_all_fseek(fd, filevec[i].offset, UPC_SEEK_SET); 
     79                upc_all_fread_local(fd, vbfp, sizeof(TYPE), filevec[i].len/sizeof(TYPE), UPC_IN_NOSYNC | UPC_OUT_NOSYNC); 
     80                vbfp += filevec[i].len / sizeof(TYPE); 
     81        } 
     82 
     83        /* Check the data integrity based on the memvec */ 
     84        vbfp = vbf; 
     85        for (i = 0; i < 2; i++) { 
     86                for (j = 0; j < memvec[i].len; j++) { 
     87                        if (*vbfp != (offsets[MYTHREAD * 2 + i] + j) % 0x80) 
     88                                GULA_FAIL("Data integrity is violated!"); 
     89                        vbfp ++; 
     90                } 
     91        } 
    8792 
    8893#if BLOCKSIZE != 0