Charm++: Charm Source Code Documentation

00001 /* -*- Mode: C; c-basic-offset:4 ; -*- */
00002 /* 
00003  *   $Id$    
00004  *
00005  *   Copyright (C) 1997 University of Chicago. 
00006  *   See COPYRIGHT notice in top-level directory.
00007  */
00008 
00009 #include "adio.h"
00010 #include "adio_extern.h"
00011 #include "ad_pvfs.h"
00012 
00013 #ifdef HAVE_PVFS_LISTIO
00014 void ADIOI_PVFS_ReadStridedListIO(ADIO_File fd, void *buf, int count,
00015                        MPI_Datatype datatype, int file_ptr_type,
00016                        ADIO_Offset offset, ADIO_Status *status, int
00017                        *error_code);
00018 #endif
00019 
00020 void ADIOI_PVFS_ReadContig(ADIO_File fd, void *buf, int count, 
00021                      MPI_Datatype datatype, int file_ptr_type,
00022                      ADIO_Offset offset, ADIO_Status *status, int *error_code)
00023 {
00024     int err=-1, datatype_size, len;
00025 #ifndef PRINT_ERR_MSG
00026     static char myname[] = "ADIOI_PVFS_READCONTIG";
00027 #endif
00028 
00029     MPI_Type_size(datatype, &datatype_size);
00030     len = datatype_size * count;
00031 
00032     if (file_ptr_type == ADIO_EXPLICIT_OFFSET) {
00033         if (fd->fp_sys_posn != offset)
00034             pvfs_lseek64(fd->fd_sys, offset, SEEK_SET);
00035         err = pvfs_read(fd->fd_sys, buf, len);
00036         fd->fp_sys_posn = offset + err;
00037         /* individual file pointer not updated */        
00038     }
00039     else {  /* read from curr. location of ind. file pointer */
00040         if (fd->fp_sys_posn != fd->fp_ind)
00041             pvfs_lseek64(fd->fd_sys, fd->fp_ind, SEEK_SET);
00042         err = pvfs_read(fd->fd_sys, buf, len);
00043         fd->fp_ind += err; 
00044         fd->fp_sys_posn = fd->fp_ind;
00045     }         
00046 
00047 #ifdef HAVE_STATUS_SET_BYTES
00048     if (err != -1) MPIR_Status_set_bytes(status, datatype, err);
00049 #endif
00050 
00051 #ifdef PRINT_ERR_MSG
00052     *error_code = (err == -1) ? MPI_ERR_UNKNOWN : MPI_SUCCESS;
00053 #else
00054     if (err == -1) {
00055         *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR,
00056                               myname, "I/O Error", "%s", strerror(errno));
00057         ADIOI_Error(fd, *error_code, myname);       
00058     }
00059     else *error_code = MPI_SUCCESS;
00060 #endif
00061 }
00062 
00063 
00064 void ADIOI_PVFS_ReadStrided(ADIO_File fd, void *buf, int count,
00065                        MPI_Datatype datatype, int file_ptr_type,
00066                        ADIO_Offset offset, ADIO_Status *status, int
00067                        *error_code)
00068 {
00069 #ifdef HAVE_PVFS_LISTIO
00070     if ( fd->hints->fs_hints.pvfs.listio_read == ADIOI_HINT_ENABLE) {
00071             ADIOI_PVFS_ReadStridedListIO(fd, buf, count, datatype, file_ptr_type,
00072                             offset, status, error_code);
00073             return;
00074     }
00075 #endif
00076 /* If hint set to DISABLE or AUTOMATIC, don't use listio */
00077     ADIOI_GEN_ReadStrided(fd, buf, count, datatype, file_ptr_type,
00078                     offset, status, error_code);
00079 }
00080 
00081 #ifdef HAVE_PVFS_LISTIO
00082 void ADIOI_PVFS_ReadStridedListIO(ADIO_File fd, void *buf, int count,
00083                        MPI_Datatype datatype, int file_ptr_type,
00084                        ADIO_Offset offset, ADIO_Status *status, int
00085                        *error_code)
00086 {
00087 /* offset is in units of etype relative to the filetype. */
00088 
00089     ADIOI_Flatlist_node *flat_buf, *flat_file;
00090     int i, j, k, l, brd_size, frd_size=0, st_index=0;
00091     int bufsize, sum, n_etypes_in_filetype, size_in_filetype;
00092     int n_filetypes, etype_in_filetype;
00093     ADIO_Offset abs_off_in_filetype=0;
00094     int filetype_size, etype_size, buftype_size;
00095     MPI_Aint filetype_extent, buftype_extent; 
00096     int buf_count, buftype_is_contig, filetype_is_contig;
00097     ADIO_Offset userbuf_off;
00098     ADIO_Offset off, disp, start_off;
00099     int flag, st_frd_size, st_n_filetypes;
00100     int new_brd_size, new_frd_size;
00101 
00102     int mem_list_count, file_list_count;
00103     char **mem_offsets;
00104     int64_t *file_offsets;
00105     int *mem_lengths;
00106     int32_t *file_lengths;
00107     int total_blks_to_read;
00108 
00109     int max_mem_list, max_file_list;
00110 
00111     int b_blks_read;
00112     int f_data_read;
00113     int size_read=0, n_read_lists, extra_blks;
00114 
00115     int end_brd_size, end_frd_size;
00116     int start_k, start_j, new_file_read, new_buffer_read;
00117     int start_mem_offset;
00118 
00119 #define MAX_ARRAY_SIZE 11
00120 
00121 #ifndef PRINT_ERR_MESG
00122   static char myname[] = "ADIOI_PVFS_ReadStrided";
00123 #endif
00124 
00125     *error_code = MPI_SUCCESS;  /* changed below if error */
00126 
00127     ADIOI_Datatype_iscontig(datatype, &buftype_is_contig);
00128     ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig);
00129     MPI_Type_size(fd->filetype, &filetype_size);
00130     if ( ! filetype_size ) {
00131         *error_code = MPI_SUCCESS; 
00132         return;
00133     }
00134 
00135     MPI_Type_extent(fd->filetype, &filetype_extent);
00136     MPI_Type_size(datatype, &buftype_size);
00137     MPI_Type_extent(datatype, &buftype_extent);
00138     etype_size = fd->etype_size;
00139 
00140     bufsize = buftype_size * count;
00141 
00142     if (!buftype_is_contig && filetype_is_contig) {
00143 
00144 /* noncontiguous in memory, contiguous in file. */
00145         int64_t file_offsets;
00146         int32_t file_lengths;
00147 
00148         ADIOI_Flatten_datatype(datatype);
00149         flat_buf = ADIOI_Flatlist;
00150         while (flat_buf->type != datatype) flat_buf = flat_buf->next;
00151 
00152         off = (file_ptr_type == ADIO_INDIVIDUAL) ? fd->fp_ind : 
00153             fd->disp + etype_size * offset;
00154 
00155         file_list_count = 1;
00156         file_offsets = off;
00157         file_lengths = 0;
00158         total_blks_to_read = count*flat_buf->count;
00159         b_blks_read = 0;
00160 
00161         /* allocate arrays according to max usage */
00162         if (total_blks_to_read > MAX_ARRAY_SIZE)
00163             mem_list_count = MAX_ARRAY_SIZE;
00164         else mem_list_count = total_blks_to_read;
00165         mem_offsets = (char**)ADIOI_Malloc(mem_list_count*sizeof(char*));
00166         mem_lengths = (int*)ADIOI_Malloc(mem_list_count*sizeof(int));
00167 
00168         j = 0;
00169         /* step through each block in memory, filling memory arrays */
00170         while (b_blks_read < total_blks_to_read) {
00171             for (i=0; i<flat_buf->count; i++) {
00172                 mem_offsets[b_blks_read % MAX_ARRAY_SIZE] = 
00173                     (char*)((char *)buf + j*buftype_extent + flat_buf->indices[i]);
00174                 mem_lengths[b_blks_read % MAX_ARRAY_SIZE] = 
00175                     flat_buf->blocklens[i];
00176                 file_lengths += flat_buf->blocklens[i];
00177                 b_blks_read++;
00178                 if (!(b_blks_read % MAX_ARRAY_SIZE) ||
00179                     (b_blks_read == total_blks_to_read)) {
00180 
00181                     /* in the case of the last read list call,
00182                        adjust mem_list_count */
00183                     if (b_blks_read == total_blks_to_read) {
00184                         mem_list_count = total_blks_to_read % MAX_ARRAY_SIZE;
00185                         /* in case last read list call fills max arrays */
00186                         if (!mem_list_count) mem_list_count = MAX_ARRAY_SIZE;
00187                     }
00188 
00189                     pvfs_read_list(fd->fd_sys ,mem_list_count, mem_offsets,
00190                                    mem_lengths, file_list_count,
00191                                    &file_offsets, &file_lengths);
00192                   
00193                     /* in the case of the last read list call, leave here */
00194                     if (b_blks_read == total_blks_to_read) break;
00195 
00196                     file_offsets += file_lengths;
00197                     file_lengths = 0;
00198                 } 
00199             } /* for (i=0; i<flat_buf->count; i++) */
00200             j++;
00201         } /* while (b_blks_read < total_blks_to_read) */
00202         ADIOI_Free(mem_offsets);
00203         ADIOI_Free(mem_lengths);
00204 
00205         if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off;
00206 
00207         fd->fp_sys_posn = -1;  /* set it to null. */
00208 
00209 #ifdef HAVE_STATUS_SET_BYTES
00210         MPIR_Status_set_bytes(status, datatype, bufsize);
00211         /* This isa temporary way of filling in status.  The right way is to
00212            keep tracke of how much data was actually read adn placed in buf
00213            by ADIOI_BUFFERED_READ. */
00214 #endif
00215         ADIOI_Delete_flattened(datatype);
00216 
00217         return;
00218     } /* if (!buftype_is_contig && filetype_is_contig) */
00219 
00220     /* know file is noncontiguous from above */
00221     /* noncontiguous in file */
00222 
00223     /* filetype already flattened in ADIO_Open */
00224     flat_file = ADIOI_Flatlist;
00225     while (flat_file->type != fd->filetype) flat_file = flat_file->next;
00226 
00227     disp = fd->disp;
00228 
00229     /* for each case - ADIO_Individual pointer or explicit, find the file
00230        offset in bytes (offset), n_filetypes (how many filetypes into
00231        file to start), frd_size (remaining amount of data in present
00232        file block), and st_index (start point in terms of blocks in
00233        starting filetype) */
00234     if (file_ptr_type == ADIO_INDIVIDUAL) {
00235         offset = fd->fp_ind; /* in bytes */
00236         n_filetypes = -1;
00237         flag = 0;
00238         while (!flag) {
00239             n_filetypes++;
00240             for (i=0; i<flat_file->count; i++) {
00241                 if (disp + flat_file->indices[i] + 
00242                     (ADIO_Offset) n_filetypes*filetype_extent +
00243                     flat_file->blocklens[i]  >= offset) {
00244                     st_index = i;
00245                     frd_size = (int) (disp + flat_file->indices[i] + 
00246                                       (ADIO_Offset) n_filetypes*filetype_extent
00247                                       + flat_file->blocklens[i] - offset);
00248                     flag = 1;
00249                     break;
00250                 }
00251             }
00252         } /* while (!flag) */
00253     } /* if (file_ptr_type == ADIOI_INDIVIDUAL) */
00254     else {
00255         n_etypes_in_filetype = filetype_size/etype_size;
00256         n_filetypes = (int) (offset / n_etypes_in_filetype);
00257         etype_in_filetype = (int) (offset % n_etypes_in_filetype);
00258         size_in_filetype = etype_in_filetype * etype_size;
00259         
00260         sum = 0;
00261         for (i=0; i<flat_file->count; i++) {
00262             sum += flat_file->blocklens[i];
00263             if (sum > size_in_filetype) {
00264                 st_index = i;
00265                 frd_size = sum - size_in_filetype;
00266                 abs_off_in_filetype = flat_file->indices[i] +
00267                     size_in_filetype - (sum - flat_file->blocklens[i]);
00268                 break;
00269             }
00270         }
00271         
00272         /* abs. offset in bytes in the file */
00273         offset = disp + (ADIO_Offset) n_filetypes*filetype_extent + 
00274             abs_off_in_filetype;
00275     } /* else [file_ptr_type != ADIOI_INDIVIDUAL] */
00276 
00277     start_off = offset;
00278     st_frd_size = frd_size;
00279     st_n_filetypes = n_filetypes;
00280     
00281     if (buftype_is_contig && !filetype_is_contig) {
00282 
00283 /* contiguous in memory, noncontiguous in file. should be the most
00284    common case. */
00285 
00286         int mem_lengths;
00287         char *mem_offsets;
00288         
00289         i = 0;
00290         j = st_index;
00291         n_filetypes = st_n_filetypes;
00292         
00293         mem_list_count = 1;
00294         
00295         /* determine how many blocks in file to read */
00296         f_data_read = ADIOI_MIN(st_frd_size, bufsize);
00297         total_blks_to_read = 1;
00298         j++;
00299         while (f_data_read < bufsize) {
00300             f_data_read += flat_file->blocklens[j];
00301             total_blks_to_read++;
00302             if (j<(flat_file->count-1)) j++;
00303             else j = 0; 
00304         }
00305       
00306         j = st_index;
00307         n_filetypes = st_n_filetypes;
00308         n_read_lists = total_blks_to_read/MAX_ARRAY_SIZE;
00309         extra_blks = total_blks_to_read%MAX_ARRAY_SIZE;
00310         
00311         mem_offsets = buf;
00312         mem_lengths = 0;
00313         
00314         /* if at least one full readlist, allocate file arrays
00315            at max array size and don't free until very end */
00316         if (n_read_lists) {
00317             file_offsets = (int64_t*)ADIOI_Malloc(MAX_ARRAY_SIZE*
00318                                                   sizeof(int64_t));
00319             file_lengths = (int32_t*)ADIOI_Malloc(MAX_ARRAY_SIZE*
00320                                                   sizeof(int32_t));
00321         }
00322         /* if there's no full readlist allocate file arrays according
00323            to needed size (extra_blks) */
00324         else {
00325             file_offsets = (int64_t*)ADIOI_Malloc(extra_blks*
00326                                                   sizeof(int64_t));
00327             file_lengths = (int32_t*)ADIOI_Malloc(extra_blks*
00328                                                   sizeof(int32_t));
00329         }
00330         
00331         /* for file arrays that are of MAX_ARRAY_SIZE, build arrays */
00332         for (i=0; i<n_read_lists; i++) {
00333             file_list_count = MAX_ARRAY_SIZE;
00334             if(!i) {
00335                 file_offsets[0] = offset;
00336                 file_lengths[0] = st_frd_size;
00337                 mem_lengths = st_frd_size;
00338             }
00339             for (k=0; k<MAX_ARRAY_SIZE; k++) {
00340                 if (i || k) {
00341                     file_offsets[k] = disp + n_filetypes*filetype_extent
00342                       + flat_file->indices[j];
00343                     file_lengths[k] = flat_file->blocklens[j];
00344                     mem_lengths += file_lengths[k];
00345                 }
00346                 if (j<(flat_file->count - 1)) j++;
00347                 else {
00348                     j = 0;
00349                     n_filetypes++;
00350                 }
00351             } /* for (k=0; k<MAX_ARRAY_SIZE; k++) */
00352             pvfs_read_list(fd->fd_sys, mem_list_count,
00353                            &mem_offsets, &mem_lengths,
00354                            file_list_count, file_offsets,
00355                            file_lengths);
00356             mem_offsets += mem_lengths;
00357             mem_lengths = 0;
00358         } /* for (i=0; i<n_read_lists; i++) */
00359 
00360         /* for file arrays smaller than MAX_ARRAY_SIZE (last read_list call) */
00361         if (extra_blks) {
00362             file_list_count = extra_blks;
00363             if(!i) {
00364                 file_offsets[0] = offset;
00365                 file_lengths[0] = st_frd_size;
00366             }
00367             for (k=0; k<extra_blks; k++) {
00368                 if(i || k) {
00369                     file_offsets[k] = disp + n_filetypes*filetype_extent +
00370                       flat_file->indices[j];
00371                     if (k == (extra_blks - 1)) {
00372                         file_lengths[k] = bufsize - (int32_t) mem_lengths
00373                           - (int32_t) mem_offsets + (int32_t)  buf;
00374                     }
00375                     else file_lengths[k] = flat_file->blocklens[j];
00376                 } /* if(i || k) */
00377                 mem_lengths += file_lengths[k];
00378                 if (j<(flat_file->count - 1)) j++;
00379                 else {
00380                     j = 0;
00381                     n_filetypes++;
00382                 }
00383             } /* for (k=0; k<extra_blks; k++) */
00384             pvfs_read_list(fd->fd_sys, mem_list_count, &mem_offsets,
00385                            &mem_lengths, file_list_count, file_offsets,
00386                            file_lengths);
00387         }
00388     }
00389     else {
00390 /* noncontiguous in memory as well as in file */
00391       
00392         ADIOI_Flatten_datatype(datatype);
00393         flat_buf = ADIOI_Flatlist;
00394         while (flat_buf->type != datatype) flat_buf = flat_buf->next;
00395 
00396         size_read = 0;
00397         n_filetypes = st_n_filetypes;
00398         frd_size = st_frd_size;
00399         brd_size = flat_buf->blocklens[0];
00400         buf_count = 0;
00401         start_mem_offset = 0;
00402         start_k = k = 0;
00403         start_j = st_index;
00404         max_mem_list = 0;
00405         max_file_list = 0;
00406 
00407         /* run through and file max_file_list and max_mem_list so that you 
00408            can allocate the file and memory arrays less than MAX_ARRAY_SIZE
00409            if possible */
00410 
00411         while (size_read < bufsize) {
00412             k = start_k;
00413             new_buffer_read = 0;
00414             mem_list_count = 0;
00415             while ((mem_list_count < MAX_ARRAY_SIZE) && 
00416                    (new_buffer_read < bufsize-size_read)) {
00417                 /* find mem_list_count and file_list_count such that both are
00418                    less than MAX_ARRAY_SIZE, the sum of their lengths are
00419                    equal, and the sum of all the data read and data to be
00420                    read in the next immediate read list is less than
00421                    bufsize */
00422                 if(mem_list_count) {
00423                     if((new_buffer_read + flat_buf->blocklens[k] + 
00424                         size_read) > bufsize) {
00425                         end_brd_size = new_buffer_read + 
00426                             flat_buf->blocklens[k] - (bufsize - size_read);
00427                         new_buffer_read = bufsize - size_read;
00428                     }
00429                     else {
00430                         new_buffer_read += flat_buf->blocklens[k];
00431                         end_brd_size = flat_buf->blocklens[k];
00432                     }
00433                 }
00434                 else {
00435                     if (brd_size > (bufsize - size_read)) {
00436                         new_buffer_read = bufsize - size_read;
00437                         brd_size = new_buffer_read;
00438                     }
00439                     else new_buffer_read = brd_size;
00440                 }
00441                 mem_list_count++;
00442                 k = (k + 1)%flat_buf->count;
00443              } /* while ((mem_list_count < MAX_ARRAY_SIZE) && 
00444                (new_buffer_read < bufsize-size_read)) */
00445             j = start_j;
00446             new_file_read = 0;
00447             file_list_count = 0;
00448             while ((file_list_count < MAX_ARRAY_SIZE) && 
00449                    (new_file_read < new_buffer_read)) {
00450                 if(file_list_count) {
00451                     if((new_file_read + flat_file->blocklens[j]) > 
00452                        new_buffer_read) {
00453                         end_frd_size = new_buffer_read - new_file_read;
00454                         new_file_read = new_buffer_read;
00455                         j--;
00456                     }
00457                     else {
00458                         new_file_read += flat_file->blocklens[j];
00459                         end_frd_size = flat_file->blocklens[j];
00460                     }
00461                 }
00462                 else {
00463                     if (frd_size > new_buffer_read) {
00464                         new_file_read = new_buffer_read;
00465                         frd_size = new_file_read;
00466                     }
00467                     else new_file_read = frd_size;
00468                 }
00469                 file_list_count++;
00470                 if (j < (flat_file->count - 1)) j++;
00471                 else j = 0;
00472                 
00473                 k = start_k;
00474                 if ((new_file_read < new_buffer_read) && 
00475                     (file_list_count == MAX_ARRAY_SIZE)) {
00476                     new_buffer_read = 0;
00477                     mem_list_count = 0;
00478                     while (new_buffer_read < new_file_read) {
00479                         if(mem_list_count) {
00480                             if((new_buffer_read + flat_buf->blocklens[k]) >
00481                                new_file_read) {
00482                                 end_brd_size = new_file_read - new_buffer_read;
00483                                 new_buffer_read = new_file_read;
00484                                 k--;
00485                             }
00486                             else {
00487                                 new_buffer_read += flat_buf->blocklens[k];
00488                                 end_brd_size = flat_buf->blocklens[k];
00489                             }
00490                         }
00491                         else {
00492                             new_buffer_read = brd_size;
00493                             if (brd_size > (bufsize - size_read)) {
00494                                 new_buffer_read = bufsize - size_read;
00495                                 brd_size = new_buffer_read;
00496                             }
00497                         }
00498                         mem_list_count++;
00499                         k = (k + 1)%flat_buf->count;
00500                     } /* while (new_buffer_read < new_file_read) */
00501                 } /* if ((new_file_read < new_buffer_read) && (file_list_count
00502                      == MAX_ARRAY_SIZE)) */
00503             } /* while ((mem_list_count < MAX_ARRAY_SIZE) && 
00504                  (new_buffer_read < bufsize-size_read)) */
00505 
00506             /*  fakes filling the readlist arrays of lengths found above  */
00507             k = start_k;
00508             j = start_j;
00509             for (i=0; i<mem_list_count; i++) {       
00510                 if(i) {
00511                     if (i == (mem_list_count - 1)) {
00512                         if (flat_buf->blocklens[k] == end_brd_size)
00513                             brd_size = flat_buf->blocklens[(k+1)%
00514                                                           flat_buf->count];
00515                         else {
00516                             brd_size = flat_buf->blocklens[k] - end_brd_size;
00517                             k--;
00518                             buf_count--;
00519                         }
00520                     }
00521                 }
00522                 buf_count++;
00523                 k = (k + 1)%flat_buf->count;
00524             } /* for (i=0; i<mem_list_count; i++) */
00525             for (i=0; i<file_list_count; i++) {
00526                 if (i) {
00527                     if (i == (file_list_count - 1)) {
00528                         if (flat_file->blocklens[j] == end_frd_size)
00529                             frd_size = flat_file->blocklens[(j+1)%
00530                                                           flat_file->count];   
00531                         else {
00532                             frd_size = flat_file->blocklens[j] - end_frd_size;
00533                             j--;
00534                         }
00535                     }
00536                 }
00537                 if (j < flat_file->count - 1) j++;
00538                 else {
00539                     j = 0;
00540                     n_filetypes++;
00541                 }
00542             } /* for (i=0; i<file_list_count; i++) */
00543             size_read += new_buffer_read;
00544             start_k = k;
00545             start_j = j;
00546             if (max_mem_list < mem_list_count)
00547                 max_mem_list = mem_list_count;
00548             if (max_file_list < file_list_count)
00549                 max_file_list = file_list_count;
00550             if (max_mem_list == max_mem_list == MAX_ARRAY_SIZE)
00551                 break;
00552         } /* while (size_read < bufsize) */
00553 
00554         mem_offsets = (char **)ADIOI_Malloc(max_mem_list*sizeof(char *));
00555         mem_lengths = (int *)ADIOI_Malloc(max_mem_list*sizeof(int));
00556         file_offsets = (int64_t *)ADIOI_Malloc(max_file_list*sizeof(int64_t));
00557         file_lengths = (int32_t *)ADIOI_Malloc(max_file_list*sizeof(int32_t));
00558             
00559         size_read = 0;
00560         n_filetypes = st_n_filetypes;
00561         frd_size = st_frd_size;
00562         brd_size = flat_buf->blocklens[0];
00563         buf_count = 0;
00564         start_mem_offset = 0;
00565         start_k = k = 0;
00566         start_j = st_index;
00567 
00568         /*  this section calculates mem_list_count and file_list_count
00569             and also finds the possibly odd sized last array elements
00570             in new_frd_size and new_brd_size  */
00571         
00572         while (size_read < bufsize) {
00573             k = start_k;
00574             new_buffer_read = 0;
00575             mem_list_count = 0;
00576             while ((mem_list_count < MAX_ARRAY_SIZE) && 
00577                    (new_buffer_read < bufsize-size_read)) {
00578                 /* find mem_list_count and file_list_count such that both are
00579                    less than MAX_ARRAY_SIZE, the sum of their lengths are
00580                    equal, and the sum of all the data read and data to be
00581                    read in the next immediate read list is less than
00582                    bufsize */
00583                 if(mem_list_count) {
00584                     if((new_buffer_read + flat_buf->blocklens[k] + 
00585                         size_read) > bufsize) {
00586                         end_brd_size = new_buffer_read + 
00587                             flat_buf->blocklens[k] - (bufsize - size_read);
00588                         new_buffer_read = bufsize - size_read;
00589                     }
00590                     else {
00591                         new_buffer_read += flat_buf->blocklens[k];
00592                         end_brd_size = flat_buf->blocklens[k];
00593                     }
00594                 }
00595                 else {
00596                     if (brd_size > (bufsize - size_read)) {
00597                         new_buffer_read = bufsize - size_read;
00598                         brd_size = new_buffer_read;
00599                     }
00600                     else new_buffer_read = brd_size;
00601                 }
00602                 mem_list_count++;
00603                 k = (k + 1)%flat_buf->count;
00604              } /* while ((mem_list_count < MAX_ARRAY_SIZE) && 
00605                (new_buffer_read < bufsize-size_read)) */
00606             j = start_j;
00607             new_file_read = 0;
00608             file_list_count = 0;
00609             while ((file_list_count < MAX_ARRAY_SIZE) && 
00610                    (new_file_read < new_buffer_read)) {
00611                 if(file_list_count) {
00612                     if((new_file_read + flat_file->blocklens[j]) > 
00613                        new_buffer_read) {
00614                         end_frd_size = new_buffer_read - new_file_read;
00615                         new_file_read = new_buffer_read;
00616                         j--;
00617                     }
00618                     else {
00619                         new_file_read += flat_file->blocklens[j];
00620                         end_frd_size = flat_file->blocklens[j];
00621                     }
00622                 }
00623                 else {
00624                     if (frd_size > new_buffer_read) {
00625                         new_file_read = new_buffer_read;
00626                         frd_size = new_file_read;
00627                     }
00628                     else new_file_read = frd_size;
00629                 }
00630                 file_list_count++;
00631                 if (j < (flat_file->count - 1)) j++;
00632                 else j = 0;
00633                 
00634                 k = start_k;
00635                 if ((new_file_read < new_buffer_read) && 
00636                     (file_list_count == MAX_ARRAY_SIZE)) {
00637                     new_buffer_read = 0;
00638                     mem_list_count = 0;
00639                     while (new_buffer_read < new_file_read) {
00640                         if(mem_list_count) {
00641                             if((new_buffer_read + flat_buf->blocklens[k]) >
00642                                new_file_read) {
00643                                 end_brd_size = new_file_read - new_buffer_read;
00644                                 new_buffer_read = new_file_read;
00645                                 k--;
00646                             }
00647                             else {
00648                                 new_buffer_read += flat_buf->blocklens[k];
00649                                 end_brd_size = flat_buf->blocklens[k];
00650                             }
00651                         }
00652                         else {
00653                             new_buffer_read = brd_size;
00654                             if (brd_size > (bufsize - size_read)) {
00655                                 new_buffer_read = bufsize - size_read;
00656                                 brd_size = new_buffer_read;
00657                             }
00658                         }
00659                         mem_list_count++;
00660                         k = (k + 1)%flat_buf->count;
00661                     } /* while (new_buffer_read < new_file_read) */
00662                 } /* if ((new_file_read < new_buffer_read) && (file_list_count
00663                      == MAX_ARRAY_SIZE)) */
00664             } /* while ((mem_list_count < MAX_ARRAY_SIZE) && 
00665                  (new_buffer_read < bufsize-size_read)) */
00666 
00667             /*  fills the allocated readlist arrays  */
00668             k = start_k;
00669             j = start_j;
00670             for (i=0; i<mem_list_count; i++) {       
00671                 mem_offsets[i] = (char*)((char *)buf + buftype_extent*
00672                                          (buf_count/flat_buf->count) +
00673                                          (int)flat_buf->indices[k]);
00674                 if(!i) {
00675                     mem_lengths[0] = brd_size;
00676                     mem_offsets[0] += flat_buf->blocklens[k] - brd_size;
00677                 }
00678                 else {
00679                     if (i == (mem_list_count - 1)) {
00680                         mem_lengths[i] = end_brd_size;
00681                         if (flat_buf->blocklens[k] == end_brd_size)
00682                             brd_size = flat_buf->blocklens[(k+1)%
00683                                                           flat_buf->count];
00684                         else {
00685                             brd_size = flat_buf->blocklens[k] - end_brd_size;
00686                             k--;
00687                             buf_count--;
00688                         }
00689                     }
00690                     else {
00691                         mem_lengths[i] = flat_buf->blocklens[k];
00692                     }
00693                 }
00694                 buf_count++;
00695                 k = (k + 1)%flat_buf->count;
00696             } /* for (i=0; i<mem_list_count; i++) */
00697             for (i=0; i<file_list_count; i++) {
00698                 file_offsets[i] = disp + flat_file->indices[j] + n_filetypes *
00699                     filetype_extent;
00700                 if (!i) {
00701                     file_lengths[0] = frd_size;
00702                     file_offsets[0] += flat_file->blocklens[j] - frd_size;
00703                 }
00704                 else {
00705                     if (i == (file_list_count - 1)) {
00706                         file_lengths[i] = end_frd_size;
00707                         if (flat_file->blocklens[j] == end_frd_size)
00708                             frd_size = flat_file->blocklens[(j+1)%
00709                                                           flat_file->count];   
00710                         else {
00711                             frd_size = flat_file->blocklens[j] - end_frd_size;
00712                             j--;
00713                         }
00714                     }
00715                     else file_lengths[i] = flat_file->blocklens[j];
00716                 }
00717                 if (j < flat_file->count - 1) j++;
00718                 else {
00719                     j = 0;
00720                     n_filetypes++;
00721                 }
00722             } /* for (i=0; i<file_list_count; i++) */
00723 
00724             /* 
00725             printf("about to call read_list in noncontig/noncontig\n");
00726             printf("offsets and lengths in terms of integers\n");
00727             printf("\nmem_list_count = %d\n", mem_list_count);
00728             for (i=0; i<mem_list_count; i++) {
00729               printf("mem_offsets[%2d] = %2d   ", i, (int)(mem_offsets[i] - (int)buf)/4);
00730               printf("mem_lengths[%2d] = %2d\n", i, mem_lengths[i]/4);
00731             }
00732             printf("\nfile_list_count = %d\n", file_list_count);
00733             for (i=0; i<file_list_count; i++) {
00734               printf("file_offsets[%2d] = %2d   ", i, (int)file_offsets[i]/4);
00735               printf("file_lengths[%2d] = %2d\n", i, file_lengths[i]/4);
00736             }
00737             printf("\n\n");
00738             */
00739             pvfs_read_list(fd->fd_sys,mem_list_count, mem_offsets,
00740                            mem_lengths, file_list_count, file_offsets,
00741                            file_lengths);
00742             size_read += new_buffer_read;
00743             start_k = k;
00744             start_j = j;
00745         } /* while (size_read < bufsize) */
00746         ADIOI_Free(mem_offsets);
00747         ADIOI_Free(mem_lengths);
00748     }
00749     ADIOI_Free(file_offsets);
00750     ADIOI_Free(file_lengths);
00751     
00752     if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off;
00753     fd->fp_sys_posn = -1;   /* set it to null. */
00754     
00755 #ifdef HAVE_STATUS_SET_BYTES
00756     MPIR_Status_set_bytes(status, datatype, bufsize);
00757     /* This is a temporary way of filling in status. The right way is to 
00758        keep track of how much data was actually read and placed in buf 
00759        by ADIOI_BUFFERED_READ. */
00760 #endif
00761     
00762     if (!buftype_is_contig) ADIOI_Delete_flattened(datatype);
00763 }
00764 #endif /* HAVE_PVFS_LISTIO */
libs/ck-libs/ampi/romio/adio/ad_pvfs/ad_pvfs_read.c
