root/ompi/mca/io/romio321/romio/adio/ad_pvfs/ad_pvfs_write.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. ADIOI_PVFS_WriteContig
  2. ADIOI_PVFS_WriteStrided
  3. ADIOI_PVFS_WriteStridedListIO
   1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
   2 /* 
   3  *
   4  *   Copyright (C) 1997 University of Chicago. 
   5  *   See COPYRIGHT notice in top-level directory.
   6  */
   7 
   8 #include "ad_pvfs.h"
   9 #include "adio_extern.h"
  10 
  11 #ifdef HAVE_PVFS_LISTIO
  12 void ADIOI_PVFS_WriteStridedListIO(ADIO_File fd, void *buf, int count,
  13                        MPI_Datatype datatype, int file_ptr_type,
  14                        ADIO_Offset offset, ADIO_Status *status, int
  15                        *error_code);
  16 #endif
  17 
  18 void ADIOI_PVFS_WriteContig(ADIO_File fd, void *buf, int count, 
  19                             MPI_Datatype datatype, int file_ptr_type,
  20                             ADIO_Offset offset, ADIO_Status *status,
  21                             int *error_code)
  22 {
  23     MPI_Count err=-1, datatype_size, len;
  24     static char myname[] = "ADIOI_PVFS_WRITECONTIG";
  25 
  26     MPI_Type_size_x(datatype, &datatype_size);
  27     len = datatype_size * count;
  28 
  29     if (file_ptr_type == ADIO_EXPLICIT_OFFSET) {
  30         if (fd->fp_sys_posn != offset) {
  31 #ifdef ADIOI_MPE_LOGGING
  32             MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL );
  33 #endif
  34             pvfs_lseek64(fd->fd_sys, offset, SEEK_SET);
  35 #ifdef ADIOI_MPE_LOGGING
  36             MPE_Log_event( ADIOI_MPE_lseek_b, 0, NULL );
  37 #endif
  38         }
  39 #ifdef ADIOI_MPE_LOGGING
  40         MPE_Log_event( ADIOI_MPE_write_a, 0, NULL );
  41 #endif
  42         err = pvfs_write(fd->fd_sys, buf, len);
  43 #ifdef ADIOI_MPE_LOGGING
  44         MPE_Log_event( ADIOI_MPE_write_b, 0, NULL );
  45 #endif
  46         if (err > 0)
  47                 fd->fp_sys_posn = offset + err;
  48         /* individual file pointer not updated */        
  49     }
  50     else { /* write from curr. location of ind. file pointer */
  51         if (fd->fp_sys_posn != fd->fp_ind) {
  52 #ifdef ADIOI_MPE_LOGGING
  53             MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL );
  54 #endif
  55             pvfs_lseek64(fd->fd_sys, fd->fp_ind, SEEK_SET);
  56 #ifdef ADIOI_MPE_LOGGING
  57             MPE_Log_event( ADIOI_MPE_lseek_b, 0, NULL );
  58 #endif
  59         }
  60 #ifdef ADIOI_MPE_LOGGING
  61         MPE_Log_event( ADIOI_MPE_write_a, 0, NULL );
  62 #endif
  63         err = pvfs_write(fd->fd_sys, buf, len);
  64 #ifdef ADIOI_MPE_LOGGING
  65         MPE_Log_event( ADIOI_MPE_write_b, 0, NULL );
  66 #endif
  67         if (err > 0)
  68                 fd->fp_ind += err;
  69         fd->fp_sys_posn = fd->fp_ind;
  70     }
  71 
  72 #ifdef HAVE_STATUS_SET_BYTES
  73     if (err != -1) MPIR_Status_set_bytes(status, datatype, err);
  74 #endif
  75 
  76     if (err == -1) {
  77         *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
  78                                            myname, __LINE__, MPI_ERR_IO,
  79                                            "**io",
  80                                            "**io %s", strerror(errno));
  81     }
  82     else *error_code = MPI_SUCCESS;
  83 }
  84 
  85 
  86 
  87 void ADIOI_PVFS_WriteStrided(ADIO_File fd, void *buf, int count,
  88                              MPI_Datatype datatype, int file_ptr_type,
  89                              ADIO_Offset offset, ADIO_Status *status, int
  90                              *error_code)
  91 {
  92 /* Since PVFS does not support file locking, can't do buffered writes
  93    as on Unix */
  94 
  95 /* offset is in units of etype relative to the filetype. */
  96 
  97     ADIOI_Flatlist_node *flat_buf, *flat_file;
  98     int i, j, k, err=-1, bwr_size, fwr_size=0, st_index=0;
  99     int num, size, sum, n_etypes_in_filetype, size_in_filetype;
 100     MPI_Count bufsize;
 101     int n_filetypes, etype_in_filetype;
 102     ADIO_Offset abs_off_in_filetype=0;
 103     MPI_Count filetype_size, etype_size, buftype_size;
 104     MPI_Aint filetype_extent, buftype_extent, indx, filetype_lb, buftype_lb;
 105     int buf_count, buftype_is_contig, filetype_is_contig;
 106     ADIO_Offset off, disp;
 107     int flag, new_bwr_size, new_fwr_size, err_flag=0;
 108     static char myname[] = "ADIOI_PVFS_WRITESTRIDED";
 109 
 110 #ifdef HAVE_PVFS_LISTIO
 111     if ( fd->hints->fs_hints.pvfs.listio_write == ADIOI_HINT_ENABLE ) {
 112             ADIOI_PVFS_WriteStridedListIO(fd, buf, count, datatype, 
 113                             file_ptr_type, offset, status, error_code);
 114             return;
 115     }
 116 #endif
 117     /* if hint set to DISABLE or AUTOMATIC, don't use listio */
 118 
 119     /* --BEGIN ERROR HANDLING-- */
 120     if (fd->atomicity) {
 121         *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
 122                                            myname, __LINE__,
 123                                            MPI_ERR_INTERN,
 124                                            "Atomic mode set in PVFS I/O function", 0);
 125         return;
 126     }
 127     /* --END ERROR HANDLING-- */
 128 
 129     ADIOI_Datatype_iscontig(datatype, &buftype_is_contig);
 130     ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig);
 131 
 132     MPI_Type_size_x(fd->filetype, &filetype_size);
 133     if ( ! filetype_size ) {
 134 #ifdef HAVE_STATUS_SET_BYTES
 135         MPIR_Status_set_bytes(status, datatype, 0);
 136 #endif
 137         *error_code = MPI_SUCCESS; 
 138         return;
 139     }
 140 
 141     MPI_Type_get_extent(fd->filetype, &filetype_lb, &filetype_extent);
 142     MPI_Type_size_x(datatype, &buftype_size);
 143     MPI_Type_get_extent(datatype, &buftype_lb, &buftype_extent);
 144     etype_size = fd->etype_size;
 145     
 146     bufsize = buftype_size * count;
 147 
 148     if (!buftype_is_contig && filetype_is_contig) {
 149         char *combine_buf, *combine_buf_ptr;
 150         ADIO_Offset combine_buf_remain;
 151 /* noncontiguous in memory, contiguous in file. use writev */
 152 
 153         flat_buf = ADIOI_Flatten_and_find(datatype);
 154 
 155         /* allocate our "combine buffer" to pack data into before writing */
 156         combine_buf = (char *) ADIOI_Malloc(fd->hints->ind_wr_buffer_size);
 157         combine_buf_ptr = combine_buf;
 158         combine_buf_remain = fd->hints->ind_wr_buffer_size;
 159 
 160         /* seek to the right spot in the file */
 161         if (file_ptr_type == ADIO_EXPLICIT_OFFSET) {
 162             off = fd->disp + etype_size * offset;
 163 #ifdef ADIOI_MPE_LOGGING
 164             MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL );
 165 #endif
 166             pvfs_lseek64(fd->fd_sys, off, SEEK_SET);
 167 #ifdef ADIOI_MPE_LOGGING
 168             MPE_Log_event( ADIOI_MPE_lseek_b, 0, NULL );
 169 #endif
 170         }
 171         else {
 172 #ifdef ADIOI_MPE_LOGGING
 173             MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL );
 174 #endif
 175             off = pvfs_lseek64(fd->fd_sys, fd->fp_ind, SEEK_SET);
 176 #ifdef ADIOI_MPE_LOGGING
 177             MPE_Log_event( ADIOI_MPE_lseek_b, 0, NULL );
 178 #endif
 179         }
 180 
 181         /* loop through all the flattened pieces.  combine into buffer until
 182          * no more will fit, then write.
 183          *
 184          * special case of a given piece being bigger than the combine buffer
 185          * is also handled.
 186          */
 187         for (j=0; j<count; j++) {
 188             for (i=0; i<flat_buf->count; i++) {
 189                 if (flat_buf->blocklens[i] > combine_buf_remain && combine_buf != combine_buf_ptr) {
 190                     /* there is data in the buffer; write out the buffer so far */
 191 #ifdef ADIOI_MPE_LOGGING
 192                     MPE_Log_event( ADIOI_MPE_write_a, 0, NULL );
 193 #endif
 194                     err = pvfs_write(fd->fd_sys,
 195                                      combine_buf,
 196                                      fd->hints->ind_wr_buffer_size - combine_buf_remain);
 197 #ifdef ADIOI_MPE_LOGGING
 198                     MPE_Log_event( ADIOI_MPE_write_b, 0, NULL );
 199 #endif
 200                     if (err == -1) err_flag = 1;
 201 
 202                     /* reset our buffer info */
 203                     combine_buf_ptr = combine_buf;
 204                     combine_buf_remain = fd->hints->ind_wr_buffer_size;
 205                 }
 206 
 207                 /* TODO: heuristic for when to not bother to use combine buffer? */
 208                 if (flat_buf->blocklens[i] >= combine_buf_remain) {
 209                     /* special case: blocklen is as big as or bigger than the combine buf;
 210                      * write directly
 211                      */
 212 #ifdef ADIOI_MPE_LOGGING
 213                     MPE_Log_event( ADIOI_MPE_write_a, 0, NULL );
 214 #endif
 215                     err = pvfs_write(fd->fd_sys,
 216                                      ((char *) buf) + j*buftype_extent + flat_buf->indices[i],
 217                                      flat_buf->blocklens[i]);
 218 #ifdef ADIOI_MPE_LOGGING
 219                     MPE_Log_event( ADIOI_MPE_write_b, 0, NULL );
 220 #endif
 221                     if (err == -1) err_flag = 1;
 222                     off += flat_buf->blocklens[i]; /* keep up with the final file offset too */
 223                 }
 224                 else {
 225                     /* copy more data into combine buffer */
 226                     memcpy(combine_buf_ptr,
 227                            ((char *) buf) + j*buftype_extent + flat_buf->indices[i],
 228                            flat_buf->blocklens[i]);
 229                     combine_buf_ptr += flat_buf->blocklens[i];
 230                     combine_buf_remain -= flat_buf->blocklens[i];
 231                     off += flat_buf->blocklens[i]; /* keep up with the final file offset too */
 232                 }
 233             }
 234         }
 235 
 236         if (combine_buf_ptr != combine_buf) {
 237             /* data left in buffer to write */
 238 #ifdef ADIOI_MPE_LOGGING
 239             MPE_Log_event( ADIOI_MPE_write_a, 0, NULL );
 240 #endif
 241             err = pvfs_write(fd->fd_sys,
 242                              combine_buf,
 243                              fd->hints->ind_wr_buffer_size - combine_buf_remain);
 244 #ifdef ADIOI_MPE_LOGGING
 245             MPE_Log_event( ADIOI_MPE_write_b, 0, NULL );
 246 #endif
 247             if (err == -1) err_flag = 1;
 248         }
 249 
 250         if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off;
 251 
 252         ADIOI_Free(combine_buf);
 253 
 254         if (err_flag) {
 255             *error_code = MPIO_Err_create_code(MPI_SUCCESS,
 256                                                MPIR_ERR_RECOVERABLE, myname,
 257                                                __LINE__, MPI_ERR_IO, "**io",
 258                                                "**io %s", strerror(errno));
 259         }
 260         else *error_code = MPI_SUCCESS;
 261     } /* if (!buftype_is_contig && filetype_is_contig)  ... */
 262 
 263     else {  /* noncontiguous in file */
 264 
 265 /* split up into several contiguous writes */
 266 
 267 /* find starting location in the file */
 268 
 269 /* filetype already flattened in ADIO_Open */
 270         flat_file = ADIOI_Flatlist;
 271         while (flat_file->type != fd->filetype) flat_file = flat_file->next;
 272         disp = fd->disp;
 273 
 274         if (file_ptr_type == ADIO_INDIVIDUAL) {
 275             offset = fd->fp_ind; /* in bytes */
 276             n_filetypes = -1;
 277             flag = 0;
 278             while (!flag) {
 279                 n_filetypes++;
 280                 for (i=0; i<flat_file->count; i++) {
 281                     if (disp + flat_file->indices[i] + 
 282                         (ADIO_Offset) n_filetypes*filetype_extent + flat_file->blocklens[i] 
 283                             >= offset) {
 284                         st_index = i;
 285                         fwr_size = disp + flat_file->indices[i] + 
 286                                 (ADIO_Offset) n_filetypes*filetype_extent
 287                                  + flat_file->blocklens[i] - offset;
 288                         flag = 1;
 289                         break;
 290                     }
 291                 }
 292             }
 293         }
 294         else {
 295             n_etypes_in_filetype = filetype_size/etype_size;
 296             n_filetypes = (int) (offset / n_etypes_in_filetype);
 297             etype_in_filetype = (int) (offset % n_etypes_in_filetype);
 298             size_in_filetype = etype_in_filetype * etype_size;
 299  
 300             sum = 0;
 301             for (i=0; i<flat_file->count; i++) {
 302                 sum += flat_file->blocklens[i];
 303                 if (sum > size_in_filetype) {
 304                     st_index = i;
 305                     fwr_size = sum - size_in_filetype;
 306                     abs_off_in_filetype = flat_file->indices[i] +
 307                         size_in_filetype - (sum - flat_file->blocklens[i]);
 308                     break;
 309                 }
 310             }
 311 
 312             /* abs. offset in bytes in the file */
 313             offset = disp + (ADIO_Offset) n_filetypes*filetype_extent + abs_off_in_filetype;
 314         }
 315 
 316         if (buftype_is_contig && !filetype_is_contig) {
 317 
 318 /* contiguous in memory, noncontiguous in file. should be the most
 319    common case. */
 320 
 321             i = 0;
 322             j = st_index;
 323             off = offset;
 324             fwr_size = ADIOI_MIN(fwr_size, bufsize);
 325             while (i < bufsize) {
 326                 if (fwr_size) { 
 327                     /* TYPE_UB and TYPE_LB can result in 
 328                        fwr_size = 0. save system call in such cases */ 
 329 #ifdef ADIOI_MPE_LOGGING
 330                     MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL );
 331 #endif
 332                     pvfs_lseek64(fd->fd_sys, off, SEEK_SET);
 333 #ifdef ADIOI_MPE_LOGGING
 334                     MPE_Log_event( ADIOI_MPE_lseek_b, 0, NULL );
 335 #endif
 336 #ifdef ADIOI_MPE_LOGGING
 337                     MPE_Log_event( ADIOI_MPE_write_a, 0, NULL );
 338 #endif
 339                     err = pvfs_write(fd->fd_sys, ((char *) buf) + i, fwr_size);
 340 #ifdef ADIOI_MPE_LOGGING
 341                     MPE_Log_event( ADIOI_MPE_write_b, 0, NULL );
 342 #endif
 343                     if (err == -1) err_flag = 1;
 344                 }
 345                 i += fwr_size;
 346 
 347                 if (off + fwr_size < disp + flat_file->indices[j] +
 348                    flat_file->blocklens[j] + (ADIO_Offset) n_filetypes*filetype_extent)
 349                        off += fwr_size;
 350                 /* did not reach end of contiguous block in filetype.
 351                    no more I/O needed. off is incremented by fwr_size. */
 352                 else {
 353                     if (j < (flat_file->count - 1)) j++;
 354                     else {
 355                         j = 0;
 356                         n_filetypes++;
 357                     }
 358                     off = disp + flat_file->indices[j] + 
 359                                         (ADIO_Offset) n_filetypes*filetype_extent;
 360                     fwr_size = ADIOI_MIN(flat_file->blocklens[j], bufsize-i);
 361                 }
 362             }
 363         }
 364         else {
 365 /* noncontiguous in memory as well as in file */
 366 
 367             flat_buf = ADIOI_Flatten_and_find(datatype);
 368 
 369             k = num = buf_count = 0;
 370             indx = flat_buf->indices[0];
 371             j = st_index;
 372             off = offset;
 373             bwr_size = flat_buf->blocklens[0];
 374 
 375             while (num < bufsize) {
 376                 size = ADIOI_MIN(fwr_size, bwr_size);
 377                 if (size) {
 378 #ifdef ADIOI_MPE_LOGGING
 379                     MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL );
 380 #endif
 381                     pvfs_lseek64(fd->fd_sys, off, SEEK_SET);
 382 #ifdef ADIOI_MPE_LOGGING
 383                     MPE_Log_event( ADIOI_MPE_lseek_b, 0, NULL );
 384 #endif
 385 #ifdef ADIOI_MPE_LOGGING
 386                     MPE_Log_event( ADIOI_MPE_write_a, 0, NULL );
 387 #endif
 388                     err = pvfs_write(fd->fd_sys, ((char *) buf) + indx, size);
 389 #ifdef ADIOI_MPE_LOGGING
 390                     MPE_Log_event( ADIOI_MPE_write_b, 0, NULL );
 391 #endif
 392                     if (err == -1) err_flag = 1;
 393                 }
 394 
 395                 new_fwr_size = fwr_size;
 396                 new_bwr_size = bwr_size;
 397 
 398                 if (size == fwr_size) {
 399 /* reached end of contiguous block in file */
 400                     if (j < (flat_file->count - 1)) j++;
 401                     else {
 402                         j = 0;
 403                         n_filetypes++;
 404                     }
 405 
 406                     off = disp + flat_file->indices[j] + 
 407                                    (ADIO_Offset) n_filetypes*filetype_extent;
 408 
 409                     new_fwr_size = flat_file->blocklens[j];
 410                     if (size != bwr_size) {
 411                         indx += size;
 412                         new_bwr_size -= size;
 413                     }
 414                 }
 415 
 416                 if (size == bwr_size) {
 417 /* reached end of contiguous block in memory */
 418 
 419                     k = (k + 1)%flat_buf->count;
 420                     buf_count++;
 421                     indx = buftype_extent*(buf_count/flat_buf->count) +
 422                         flat_buf->indices[k]; 
 423                     new_bwr_size = flat_buf->blocklens[k];
 424                     if (size != fwr_size) {
 425                         off += size;
 426                         new_fwr_size -= size;
 427                     }
 428                 }
 429                 num += size;
 430                 fwr_size = new_fwr_size;
 431                 bwr_size = new_bwr_size;
 432             }
 433         }
 434 
 435         if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off;
 436         if (err_flag) {
 437             *error_code = MPIO_Err_create_code(MPI_SUCCESS,
 438                                                MPIR_ERR_RECOVERABLE, myname,
 439                                                __LINE__, MPI_ERR_IO, "**io",
 440                                                "**io %s", strerror(errno));
 441         }
 442         else *error_code = MPI_SUCCESS;
 443     }
 444 
 445     fd->fp_sys_posn = -1;   /* set it to null. */
 446 
 447 #ifdef HAVE_STATUS_SET_BYTES
 448     MPIR_Status_set_bytes(status, datatype, bufsize);
 449 /* This is a temporary way of filling in status. The right way is to 
 450    keep track of how much data was actually written by ADIOI_BUFFERED_WRITE. */
 451 #endif
 452 
 453     if (!buftype_is_contig) ADIOI_Delete_flattened(datatype);
 454 }
 455 
 456 #ifdef HAVE_PVFS_LISTIO
 457 void ADIOI_PVFS_WriteStridedListIO(ADIO_File fd, void *buf, int count,
 458                        MPI_Datatype datatype, int file_ptr_type,
 459                        ADIO_Offset offset, ADIO_Status *status, int
 460                        *error_code) 
 461 {
 462 /* Since PVFS does not support file locking, can't do buffered writes
 463    as on Unix */
 464 
 465 /* offset is in units of etype relative to the filetype. */
 466 
 467     ADIOI_Flatlist_node *flat_buf, *flat_file;
 468     int i, j, k, err=-1, bwr_size, fwr_size=0, st_index=0;
 469     int size, sum, n_etypes_in_filetype, size_in_filetype;
 470     MPI_Count bufsize;
 471     int n_filetypes, etype_in_filetype;
 472     ADIO_Offset abs_off_in_filetype=0;
 473     MPI_Count filetype_size, etype_size, buftype_size;
 474     MPI_Aint filetype_extent, buftype_extent, filetype_lb, buftype_lb;
 475     int buf_count, buftype_is_contig, filetype_is_contig;
 476     ADIO_Offset userbuf_off;
 477     ADIO_Offset off, disp, start_off;
 478     int flag, st_fwr_size, st_n_filetypes;
 479     int new_bwr_size, new_fwr_size, err_flag=0;
 480 
 481     int mem_list_count, file_list_count;
 482     char ** mem_offsets;
 483     int64_t *file_offsets;
 484     int *mem_lengths;
 485     int32_t *file_lengths;
 486     int total_blks_to_write;
 487 
 488     int max_mem_list, max_file_list;
 489 
 490     int b_blks_wrote;
 491     int f_data_wrote;
 492     int size_wrote=0, n_write_lists, extra_blks;
 493 
 494     int end_bwr_size, end_fwr_size;
 495     int start_k, start_j, new_file_write, new_buffer_write;
 496     int start_mem_offset;
 497 #define MAX_ARRAY_SIZE 1024
 498     static char myname[] = "ADIOI_PVFS_WRITESTRIDED";
 499 
 500 /* PFS file pointer modes are not relevant here, because PFS does
 501    not support strided accesses. */
 502 
 503     /* --BEGIN ERROR HANDLING-- */
 504     if (fd->atomicity) {
 505         *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
 506                                            myname, __LINE__,
 507                                            MPI_ERR_INTERN,
 508                                            "Atomic mode set in PVFS I/O function", 0);
 509         return;
 510     }
 511     /* --END ERROR HANDLING-- */
 512 
 513     ADIOI_Datatype_iscontig(datatype, &buftype_is_contig);
 514     ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig);
 515 
 516     MPI_Type_size_x(fd->filetype, &filetype_size);
 517     if ( ! filetype_size ) {
 518 #ifdef HAVE_STATUS_SET_BYTES
 519         MPIR_Status_set_bytes(status, datatype, 0);
 520 #endif
 521         *error_code = MPI_SUCCESS; 
 522         return;
 523     }
 524 
 525     MPI_Type_get_extent(fd->filetype, &filetype_lb, &filetype_extent);
 526     MPI_Type_size_x(datatype, &buftype_size);
 527     MPI_Type_get_extent(datatype, &buftype_lb, &buftype_extent);
 528     etype_size = fd->etype_size;
 529     
 530     bufsize = buftype_size * count;
 531 
 532     if (!buftype_is_contig && filetype_is_contig) {
 533 
 534 /* noncontiguous in memory, contiguous in file.  */
 535         int64_t file_offsets;
 536         int32_t file_lengths;
 537 
 538         flat_buf = ADIOI_Flatten_and_find(datatype);
 539         
 540         if (file_ptr_type == ADIO_EXPLICIT_OFFSET) {
 541             off = fd->disp + etype_size * offset;
 542 #ifdef ADIOI_MPE_LOGGING
 543             MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL );
 544 #endif
 545             pvfs_lseek64(fd->fd_sys, fd->fp_ind, SEEK_SET);
 546 #ifdef ADIOI_MPE_LOGGING
 547             MPE_Log_event( ADIOI_MPE_lseek_b, 0, NULL );
 548 #endif
 549         }
 550         else {
 551 #ifdef ADIOI_MPE_LOGGING
 552             MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL );
 553 #endif
 554             off = pvfs_lseek64(fd->fd_sys, fd->fp_ind, SEEK_SET);
 555 #ifdef ADIOI_MPE_LOGGING
 556             MPE_Log_event( ADIOI_MPE_lseek_b, 0, NULL );
 557 #endif
 558         }
 559 
 560         file_list_count = 1;
 561         file_offsets = off;
 562         file_lengths = 0;
 563         total_blks_to_write = count*flat_buf->count;
 564         b_blks_wrote = 0;
 565 
 566         /* allocate arrays according to max usage */
 567         if (total_blks_to_write > MAX_ARRAY_SIZE)
 568             mem_list_count = MAX_ARRAY_SIZE;
 569         else mem_list_count = total_blks_to_write;
 570         mem_offsets = (char**)ADIOI_Malloc(mem_list_count*sizeof(char*));
 571         mem_lengths = (int*)ADIOI_Malloc(mem_list_count*sizeof(int));
 572 
 573         j = 0;
 574         /* step through each block in memory, filling memory arrays */
 575         while (b_blks_wrote < total_blks_to_write) {
 576             for (i=0; i<flat_buf->count; i++) {
 577                 mem_offsets[b_blks_wrote % MAX_ARRAY_SIZE] = 
 578                     ((char*)buf + j*buftype_extent + flat_buf->indices[i]);
 579                 mem_lengths[b_blks_wrote % MAX_ARRAY_SIZE] = 
 580                     flat_buf->blocklens[i];
 581                 file_lengths += flat_buf->blocklens[i];
 582                 b_blks_wrote++;
 583                 if (!(b_blks_wrote % MAX_ARRAY_SIZE) ||
 584                     (b_blks_wrote == total_blks_to_write)) {
 585 
 586                     /* in the case of the last read list call,
 587                        adjust mem_list_count */
 588                     if (b_blks_wrote == total_blks_to_write) {
 589                         mem_list_count = total_blks_to_write % MAX_ARRAY_SIZE;
 590                         /* in case last read list call fills max arrays */
 591                         if (!mem_list_count) mem_list_count = MAX_ARRAY_SIZE;
 592                     }
 593 
 594                     pvfs_write_list(fd->fd_sys ,mem_list_count, mem_offsets,
 595                                    mem_lengths, file_list_count,
 596                                    &file_offsets, &file_lengths);
 597                   
 598                     /* in the case of the last read list call, leave here */
 599                     if (b_blks_wrote == total_blks_to_write) break;
 600 
 601                     file_offsets += file_lengths;
 602                     file_lengths = 0;
 603                 } 
 604             } /* for (i=0; i<flat_buf->count; i++) */
 605             j++;
 606         } /* while (b_blks_wrote < total_blks_to_write) */
 607         ADIOI_Free(mem_offsets);
 608         ADIOI_Free(mem_lengths);
 609 
 610         if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off;
 611 
 612         if (err_flag) {
 613             *error_code = MPIO_Err_create_code(MPI_SUCCESS,
 614                                                MPIR_ERR_RECOVERABLE, myname,
 615                                                __LINE__, MPI_ERR_IO, "**io",
 616                                                "**io %s", strerror(errno));
 617         }
 618         else *error_code = MPI_SUCCESS;
 619 
 620         fd->fp_sys_posn = -1;   /* clear this. */
 621 
 622 #ifdef HAVE_STATUS_SET_BYTES
 623         MPIR_Status_set_bytes(status, datatype, bufsize);
 624 /* This is a temporary way of filling in status. The right way is to 
 625    keep track of how much data was actually written by ADIOI_BUFFERED_WRITE. */
 626 #endif
 627 
 628         ADIOI_Delete_flattened(datatype);
 629         return;
 630     } /* if (!buftype_is_contig && filetype_is_contig) */
 631 
 632     /* already know that file is noncontiguous from above */
 633     /* noncontiguous in file */
 634 
 635 /* filetype already flattened in ADIO_Open */
 636     flat_file = ADIOI_Flatlist;
 637     while (flat_file->type != fd->filetype) flat_file = flat_file->next;
 638 
 639     disp = fd->disp;
 640 
 641     /* for each case - ADIO_Individual pointer or explicit, find offset
 642        (file offset in bytes), n_filetypes (how many filetypes into file 
 643        to start), fwr_size (remaining amount of data in present file
 644        block), and st_index (start point in terms of blocks in starting
 645        filetype) */
 646     if (file_ptr_type == ADIO_INDIVIDUAL) {
 647         offset = fd->fp_ind; /* in bytes */
 648         n_filetypes = -1;
 649         flag = 0;
 650         while (!flag) {
 651             n_filetypes++;
 652             for (i=0; i<flat_file->count; i++) {
 653                 if (disp + flat_file->indices[i] + 
 654                     (ADIO_Offset) n_filetypes*filetype_extent +
 655                       flat_file->blocklens[i] >= offset) {
 656                   st_index = i;
 657                   fwr_size = disp + flat_file->indices[i] + 
 658                     (ADIO_Offset) n_filetypes*filetype_extent
 659                     + flat_file->blocklens[i] - offset;
 660                   flag = 1;
 661                   break;
 662                 }
 663             }
 664         } /* while (!flag) */
 665     } /* if (file_ptr_type == ADIO_INDIVIDUAL) */
 666     else {
 667         n_etypes_in_filetype = filetype_size/etype_size;
 668         n_filetypes = (int) (offset / n_etypes_in_filetype);
 669         etype_in_filetype = (int) (offset % n_etypes_in_filetype);
 670         size_in_filetype = etype_in_filetype * etype_size;
 671         
 672         sum = 0;
 673         for (i=0; i<flat_file->count; i++) {
 674             sum += flat_file->blocklens[i];
 675             if (sum > size_in_filetype) {
 676                 st_index = i;
 677                 fwr_size = sum - size_in_filetype;
 678                 abs_off_in_filetype = flat_file->indices[i] +
 679                     size_in_filetype - (sum - flat_file->blocklens[i]);
 680                 break;
 681             }
 682         }
 683 
 684         /* abs. offset in bytes in the file */
 685         offset = disp + (ADIO_Offset) n_filetypes*filetype_extent +
 686             abs_off_in_filetype;
 687     } /* else [file_ptr_type != ADIO_INDIVIDUAL] */
 688 
 689     start_off = offset;
 690     st_fwr_size = fwr_size;
 691     st_n_filetypes = n_filetypes;
 692     
 693     if (buftype_is_contig && !filetype_is_contig) {
 694 
 695 /* contiguous in memory, noncontiguous in file. should be the most
 696    common case. */
 697 
 698         int mem_lengths;
 699         char *mem_offsets;
 700         
 701         i = 0;
 702         j = st_index;
 703         off = offset;
 704         n_filetypes = st_n_filetypes;
 705         
 706         mem_list_count = 1;
 707         
 708         /* determine how many blocks in file to read */
 709         f_data_wrote = ADIOI_MIN(st_fwr_size, bufsize);
 710         total_blks_to_write = 1;
 711         j++;
 712         while (f_data_wrote < bufsize) {
 713             f_data_wrote += flat_file->blocklens[j];
 714             total_blks_to_write++;
 715             if (j<(flat_file->count-1)) j++;
 716             else j = 0; 
 717         }
 718             
 719         j = st_index;
 720         n_filetypes = st_n_filetypes;
 721         n_write_lists = total_blks_to_write/MAX_ARRAY_SIZE;
 722         extra_blks = total_blks_to_write%MAX_ARRAY_SIZE;
 723         
 724         mem_offsets = buf;
 725         mem_lengths = 0;
 726         
 727         /* if at least one full readlist, allocate file arrays
 728            at max array size and don't free until very end */
 729         if (n_write_lists) {
 730             file_offsets = (int64_t*)ADIOI_Malloc(MAX_ARRAY_SIZE*
 731                                                   sizeof(int64_t));
 732             file_lengths = (int32_t*)ADIOI_Malloc(MAX_ARRAY_SIZE*
 733                                                   sizeof(int32_t));
 734         }
 735         /* if there's no full readlist allocate file arrays according
 736            to needed size (extra_blks) */
 737         else {
 738             file_offsets = (int64_t*)ADIOI_Malloc(extra_blks*
 739                                                   sizeof(int64_t));
 740             file_lengths = (int32_t*)ADIOI_Malloc(extra_blks*
 741                                                   sizeof(int32_t));
 742         }
 743         
 744         /* for file arrays that are of MAX_ARRAY_SIZE, build arrays */
 745         for (i=0; i<n_write_lists; i++) {
 746             file_list_count = MAX_ARRAY_SIZE;
 747             if(!i) {
 748                 file_offsets[0] = offset;
 749                 file_lengths[0] = st_fwr_size;
 750                 mem_lengths = st_fwr_size;
 751             }
 752             for (k=0; k<MAX_ARRAY_SIZE; k++) {
 753                 if (i || k) {
 754                     file_offsets[k] = disp + n_filetypes*filetype_extent
 755                       + flat_file->indices[j];
 756                     file_lengths[k] = flat_file->blocklens[j];
 757                     mem_lengths += file_lengths[k];
 758                 }
 759                 if (j<(flat_file->count - 1)) j++;
 760                 else {
 761                     j = 0;
 762                     n_filetypes++;
 763                 }
 764             } /* for (k=0; k<MAX_ARRAY_SIZE; k++) */
 765             pvfs_write_list(fd->fd_sys, mem_list_count,
 766                            &mem_offsets, &mem_lengths,
 767                            file_list_count, file_offsets,
 768                            file_lengths);
 769             mem_offsets += mem_lengths;
 770             mem_lengths = 0;
 771         } /* for (i=0; i<n_write_lists; i++) */
 772 
 773         /* for file arrays smaller than MAX_ARRAY_SIZE (last read_list call) */
 774         if (extra_blks) {
 775             file_list_count = extra_blks;
 776             if(!i) {
 777                 file_offsets[0] = offset;
 778                 file_lengths[0] = st_fwr_size;
 779             }
 780             for (k=0; k<extra_blks; k++) {
 781                 if(i || k) {
 782                     file_offsets[k] = disp + n_filetypes*filetype_extent +
 783                       flat_file->indices[j];
 784                     if (k == (extra_blks - 1)) {
 785                         file_lengths[k] = bufsize - (int32_t) mem_lengths
 786                           - (int32_t) mem_offsets + (int32_t)  buf;
 787                     }
 788                     else file_lengths[k] = flat_file->blocklens[j];
 789                 } /* if(i || k) */
 790                 mem_lengths += file_lengths[k];
 791                 if (j<(flat_file->count - 1)) j++;
 792                 else {
 793                     j = 0;
 794                     n_filetypes++;
 795                 }
 796             } /* for (k=0; k<extra_blks; k++) */
 797             pvfs_write_list(fd->fd_sys, mem_list_count, &mem_offsets,
 798                            &mem_lengths, file_list_count, file_offsets,
 799                            file_lengths);
 800         }
 801     } 
 802     else {
 803         /* noncontiguous in memory as well as in file */
 804 
 805         flat_buf = ADIOI_Flatten_and_find(datatype);
 806 
 807         size_wrote = 0;
 808         n_filetypes = st_n_filetypes;
 809         fwr_size = st_fwr_size;
 810         bwr_size = flat_buf->blocklens[0];
 811         buf_count = 0;
 812         start_mem_offset = 0;
 813         start_k = k = 0;
 814         start_j = st_index;
 815         max_mem_list = 0;
 816         max_file_list = 0;
 817 
 818         /* run through and file max_file_list and max_mem_list so that you 
 819            can allocate the file and memory arrays less than MAX_ARRAY_SIZE
 820            if possible */
 821 
 822         while (size_wrote < bufsize) {
 823             k = start_k;
 824             new_buffer_write = 0;
 825             mem_list_count = 0;
 826             while ((mem_list_count < MAX_ARRAY_SIZE) && 
 827                    (new_buffer_write < bufsize-size_wrote)) {
 828                 /* find mem_list_count and file_list_count such that both are
 829                    less than MAX_ARRAY_SIZE, the sum of their lengths are
 830                    equal, and the sum of all the data read and data to be
 831                    read in the next immediate read list is less than
 832                    bufsize */
 833                 if(mem_list_count) {
 834                     if((new_buffer_write + flat_buf->blocklens[k] + 
 835                         size_wrote) > bufsize) {
 836                         end_bwr_size = new_buffer_write + 
 837                             flat_buf->blocklens[k] - (bufsize - size_wrote);
 838                         new_buffer_write = bufsize - size_wrote;
 839                     }
 840                     else {
 841                         new_buffer_write += flat_buf->blocklens[k];
 842                         end_bwr_size = flat_buf->blocklens[k];
 843                     }
 844                 }
 845                 else {
 846                     if (bwr_size > (bufsize - size_wrote)) {
 847                         new_buffer_write = bufsize - size_wrote;
 848                         bwr_size = new_buffer_write;
 849                     }
 850                     else new_buffer_write = bwr_size;
 851                 }
 852                 mem_list_count++;
 853                 k = (k + 1)%flat_buf->count;
 854              } /* while ((mem_list_count < MAX_ARRAY_SIZE) && 
 855                (new_buffer_write < bufsize-size_wrote)) */
 856             j = start_j;
 857             new_file_write = 0;
 858             file_list_count = 0;
 859             while ((file_list_count < MAX_ARRAY_SIZE) && 
 860                    (new_file_write < new_buffer_write)) {
 861                 if(file_list_count) {
 862                     if((new_file_write + flat_file->blocklens[j]) > 
 863                        new_buffer_write) {
 864                         end_fwr_size = new_buffer_write - new_file_write;
 865                         new_file_write = new_buffer_write;
 866                         j--;
 867                     }
 868                     else {
 869                         new_file_write += flat_file->blocklens[j];
 870                         end_fwr_size = flat_file->blocklens[j];
 871                     }
 872                 }
 873                 else {
 874                     if (fwr_size > new_buffer_write) {
 875                         new_file_write = new_buffer_write;
 876                         fwr_size = new_file_write;
 877                     }
 878                     else new_file_write = fwr_size;
 879                 }
 880                 file_list_count++;
 881                 if (j < (flat_file->count - 1)) j++;
 882                 else j = 0;
 883                 
 884                 k = start_k;
 885                 if ((new_file_write < new_buffer_write) && 
 886                     (file_list_count == MAX_ARRAY_SIZE)) {
 887                     new_buffer_write = 0;
 888                     mem_list_count = 0;
 889                     while (new_buffer_write < new_file_write) {
 890                         if(mem_list_count) {
 891                             if((new_buffer_write + flat_buf->blocklens[k]) >
 892                                new_file_write) {
 893                                 end_bwr_size = new_file_write - 
 894                                     new_buffer_write;
 895                                 new_buffer_write = new_file_write;
 896                                 k--;
 897                             }
 898                             else {
 899                                 new_buffer_write += flat_buf->blocklens[k];
 900                                 end_bwr_size = flat_buf->blocklens[k];
 901                             }
 902                         }
 903                         else {
 904                             new_buffer_write = bwr_size;
 905                             if (bwr_size > (bufsize - size_wrote)) {
 906                                 new_buffer_write = bufsize - size_wrote;
 907                                 bwr_size = new_buffer_write;
 908                             }
 909                         }
 910                         mem_list_count++;
 911                         k = (k + 1)%flat_buf->count;
 912                     } /* while (new_buffer_write < new_file_write) */
 913                 } /* if ((new_file_write < new_buffer_write) &&
 914                      (file_list_count == MAX_ARRAY_SIZE)) */
 915             } /* while ((mem_list_count < MAX_ARRAY_SIZE) && 
 916                  (new_buffer_write < bufsize-size_wrote)) */
 917 
 918             /*  fakes filling the writelist arrays of lengths found above  */
 919             k = start_k;
 920             j = start_j;
 921             for (i=0; i<mem_list_count; i++) {       
 922                 if(i) {
 923                     if (i == (mem_list_count - 1)) {
 924                         if (flat_buf->blocklens[k] == end_bwr_size)
 925                             bwr_size = flat_buf->blocklens[(k+1)%
 926                                                           flat_buf->count];
 927                         else {
 928                             bwr_size = flat_buf->blocklens[k] - end_bwr_size;
 929                             k--;
 930                             buf_count--;
 931                         }
 932                     }
 933                 }
 934                 buf_count++;
 935                 k = (k + 1)%flat_buf->count;
 936             } /* for (i=0; i<mem_list_count; i++) */
 937             for (i=0; i<file_list_count; i++) {
 938                 if (i) {
 939                     if (i == (file_list_count - 1)) {
 940                         if (flat_file->blocklens[j] == end_fwr_size)
 941                             fwr_size = flat_file->blocklens[(j+1)%
 942                                                           flat_file->count];   
 943                         else {
 944                             fwr_size = flat_file->blocklens[j] - end_fwr_size;
 945                             j--;
 946                         }
 947                     }
 948                 }
 949                 if (j < flat_file->count - 1) j++;
 950                 else {
 951                     j = 0;
 952                     n_filetypes++;
 953                 }
 954             } /* for (i=0; i<file_list_count; i++) */
 955             size_wrote += new_buffer_write;
 956             start_k = k;
 957             start_j = j;
 958             if (max_mem_list < mem_list_count)
 959                 max_mem_list = mem_list_count;
 960             if (max_file_list < file_list_count)
 961                 max_file_list = file_list_count;
 962         } /* while (size_wrote < bufsize) */
 963 
 964         mem_offsets = (char **)ADIOI_Malloc(max_mem_list*sizeof(char *));
 965         mem_lengths = (int *)ADIOI_Malloc(max_mem_list*sizeof(int));
 966         file_offsets = (int64_t *)ADIOI_Malloc(max_file_list*sizeof(int64_t));
 967         file_lengths = (int32_t *)ADIOI_Malloc(max_file_list*sizeof(int32_t));
 968             
 969         size_wrote = 0;
 970         n_filetypes = st_n_filetypes;
 971         fwr_size = st_fwr_size;
 972         bwr_size = flat_buf->blocklens[0];
 973         buf_count = 0;
 974         start_mem_offset = 0;
 975         start_k = k = 0;
 976         start_j = st_index;
 977 
 978         /*  this section calculates mem_list_count and file_list_count
 979             and also finds the possibly odd sized last array elements
 980             in new_fwr_size and new_bwr_size  */
 981         
 982         while (size_wrote < bufsize) {
 983             k = start_k;
 984             new_buffer_write = 0;
 985             mem_list_count = 0;
 986             while ((mem_list_count < MAX_ARRAY_SIZE) && 
 987                    (new_buffer_write < bufsize-size_wrote)) {
 988                 /* find mem_list_count and file_list_count such that both are
 989                    less than MAX_ARRAY_SIZE, the sum of their lengths are
 990                    equal, and the sum of all the data read and data to be
 991                    read in the next immediate read list is less than
 992                    bufsize */
 993                 if(mem_list_count) {
 994                     if((new_buffer_write + flat_buf->blocklens[k] + 
 995                         size_wrote) > bufsize) {
 996                         end_bwr_size = new_buffer_write + 
 997                             flat_buf->blocklens[k] - (bufsize - size_wrote);
 998                         new_buffer_write = bufsize - size_wrote;
 999                     }
1000                     else {
1001                         new_buffer_write += flat_buf->blocklens[k];
1002                         end_bwr_size = flat_buf->blocklens[k];
1003                     }
1004                 }
1005                 else {
1006                     if (bwr_size > (bufsize - size_wrote)) {
1007                         new_buffer_write = bufsize - size_wrote;
1008                         bwr_size = new_buffer_write;
1009                     }
1010                     else new_buffer_write = bwr_size;
1011                 }
1012                 mem_list_count++;
1013                 k = (k + 1)%flat_buf->count;
1014              } /* while ((mem_list_count < MAX_ARRAY_SIZE) && 
1015                (new_buffer_write < bufsize-size_wrote)) */
1016             j = start_j;
1017             new_file_write = 0;
1018             file_list_count = 0;
1019             while ((file_list_count < MAX_ARRAY_SIZE) && 
1020                    (new_file_write < new_buffer_write)) {
1021                 if(file_list_count) {
1022                     if((new_file_write + flat_file->blocklens[j]) > 
1023                        new_buffer_write) {
1024                         end_fwr_size = new_buffer_write - new_file_write;
1025                         new_file_write = new_buffer_write;
1026                         j--;
1027                     }
1028                     else {
1029                         new_file_write += flat_file->blocklens[j];
1030                         end_fwr_size = flat_file->blocklens[j];
1031                     }
1032                 }
1033                 else {
1034                     if (fwr_size > new_buffer_write) {
1035                         new_file_write = new_buffer_write;
1036                         fwr_size = new_file_write;
1037                     }
1038                     else new_file_write = fwr_size;
1039                 }
1040                 file_list_count++;
1041                 if (j < (flat_file->count - 1)) j++;
1042                 else j = 0;
1043                 
1044                 k = start_k;
1045                 if ((new_file_write < new_buffer_write) && 
1046                     (file_list_count == MAX_ARRAY_SIZE)) {
1047                     new_buffer_write = 0;
1048                     mem_list_count = 0;
1049                     while (new_buffer_write < new_file_write) {
1050                         if(mem_list_count) {
1051                             if((new_buffer_write + flat_buf->blocklens[k]) >
1052                                new_file_write) {
1053                                 end_bwr_size = new_file_write -
1054                                   new_buffer_write;
1055                                 new_buffer_write = new_file_write;
1056                                 k--;
1057                             }
1058                             else {
1059                                 new_buffer_write += flat_buf->blocklens[k];
1060                                 end_bwr_size = flat_buf->blocklens[k];
1061                             }
1062                         }
1063                         else {
1064                             new_buffer_write = bwr_size;
1065                             if (bwr_size > (bufsize - size_wrote)) {
1066                                 new_buffer_write = bufsize - size_wrote;
1067                                 bwr_size = new_buffer_write;
1068                             }
1069                         }
1070                         mem_list_count++;
1071                         k = (k + 1)%flat_buf->count;
1072                     } /* while (new_buffer_write < new_file_write) */
1073                 } /* if ((new_file_write < new_buffer_write) &&
1074                      (file_list_count == MAX_ARRAY_SIZE)) */
1075             } /* while ((mem_list_count < MAX_ARRAY_SIZE) && 
1076                  (new_buffer_write < bufsize-size_wrote)) */
1077 
1078             /*  fills the allocated readlist arrays  */
1079             k = start_k;
1080             j = start_j;
1081             for (i=0; i<mem_list_count; i++) {       
1082                 mem_offsets[i] = ((char*)buf + buftype_extent*
1083                                          (buf_count/flat_buf->count) +
1084                                          (int)flat_buf->indices[k]);
1085                 
1086                 if(!i) {
1087                     mem_lengths[0] = bwr_size;
1088                     mem_offsets[0] += flat_buf->blocklens[k] - bwr_size;
1089                 }
1090                 else {
1091                     if (i == (mem_list_count - 1)) {
1092                         mem_lengths[i] = end_bwr_size;
1093                         if (flat_buf->blocklens[k] == end_bwr_size)
1094                             bwr_size = flat_buf->blocklens[(k+1)%
1095                                                           flat_buf->count];
1096                         else {
1097                             bwr_size = flat_buf->blocklens[k] - end_bwr_size;
1098                             k--;
1099                             buf_count--;
1100                         }
1101                     }
1102                     else {
1103                         mem_lengths[i] = flat_buf->blocklens[k];
1104                     }
1105                 }
1106                 buf_count++;
1107                 k = (k + 1)%flat_buf->count;
1108             } /* for (i=0; i<mem_list_count; i++) */
1109             for (i=0; i<file_list_count; i++) {
1110                 file_offsets[i] = disp + flat_file->indices[j] + n_filetypes *
1111                     filetype_extent;
1112                 if (!i) {
1113                     file_lengths[0] = fwr_size;
1114                     file_offsets[0] += flat_file->blocklens[j] - fwr_size;
1115                 }
1116                 else {
1117                     if (i == (file_list_count - 1)) {
1118                         file_lengths[i] = end_fwr_size;
1119                         if (flat_file->blocklens[j] == end_fwr_size)
1120                             fwr_size = flat_file->blocklens[(j+1)%
1121                                                           flat_file->count];   
1122                         else {
1123                             fwr_size = flat_file->blocklens[j] - end_fwr_size;
1124                             j--;
1125                         }
1126                     }
1127                     else file_lengths[i] = flat_file->blocklens[j];
1128                 }
1129                 if (j < flat_file->count - 1) j++;
1130                 else {
1131                     j = 0;
1132                     n_filetypes++;
1133                 }
1134             } /* for (i=0; i<file_list_count; i++) */
1135             pvfs_write_list(fd->fd_sys,mem_list_count, mem_offsets,
1136                            mem_lengths, file_list_count, file_offsets,
1137                            file_lengths);
1138             size_wrote += new_buffer_write;
1139             start_k = k;
1140             start_j = j;
1141         } /* while (size_wrote < bufsize) */
1142         ADIOI_Free(mem_offsets);
1143         ADIOI_Free(mem_lengths);
1144     }
1145     ADIOI_Free(file_offsets);
1146     ADIOI_Free(file_lengths);
1147 
1148     if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off;
1149     if (err_flag) {
1150         *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
1151                                            myname, __LINE__, MPI_ERR_IO,
1152                                            "**io",
1153                                            "**io %s", strerror(errno));
1154     }
1155     else *error_code = MPI_SUCCESS;
1156 
1157     fd->fp_sys_posn = -1;   /* set it to null. */
1158 
1159 #ifdef HAVE_STATUS_SET_BYTES
1160     MPIR_Status_set_bytes(status, datatype, bufsize);
1161 /* This is a temporary way of filling in status. The right way is to 
1162    keep track of how much data was actually written by ADIOI_BUFFERED_WRITE. */
1163 #endif
1164 
1165     if (!buftype_is_contig) ADIOI_Delete_flattened(datatype);
1166 }
1167 #endif /* HAVE_PVFS_LISTIO */
/* [<][>][^][v][top][bottom][index][help] */