root/ompi/mca/io/romio321/romio/adio/ad_xfs/ad_xfs_read.c

DEFINITIONS

1. ADIOI_XFS_ReadContig
2. ADIOI_XFS_Aligned_Mem_File_Read

   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_xfs.h"
   9 #ifdef HAVE_MALLOC_H
  10 #include <malloc.h>
  11 #endif
  12 
  13 /* style: allow:free:2 sig:0 */
  14 
  15 static void ADIOI_XFS_Aligned_Mem_File_Read(ADIO_File fd, void *buf, int len, 
  16                                              ADIO_Offset offset, int *err);
  17 
  18 void ADIOI_XFS_ReadContig(ADIO_File fd, void *buf, int count, 
  19                      MPI_Datatype datatype, int file_ptr_type,
  20                      ADIO_Offset offset, ADIO_Status *status, int *error_code)
  21 {
  22     int diff, size, nbytes;
  23     MPI_Count err=-1, datatype_size, len;
  24     void *newbuf;
  25     static char myname[] = "ADIOI_XFS_READCONTIG";
  26 
  27     MPI_Type_size_x(datatype, &datatype_size);
  28     len = datatype_size * count;
  29 
  30     fd->fp_sys_posn = -1; /* set it to null, since we are using pread */
  31 
  32     if (file_ptr_type == ADIO_INDIVIDUAL) offset = fd->fp_ind;
  33 
  34     if (!(fd->direct_read))     /* direct I/O not enabled */
  35         err = pread(fd->fd_sys, buf, len, offset);
  36     else {       /* direct I/O enabled */
  37 
  38         /* (1) if mem_aligned && file_aligned 
  39                     use direct I/O to read up to correct io_size
  40                     use buffered I/O for remaining  */
  41 
  42         if (!(((long) buf) % fd->d_mem) && !(offset % fd->d_miniosz)) 
  43             ADIOI_XFS_Aligned_Mem_File_Read(fd, buf, len, offset, &err);
  44 
  45         /* (2) if !file_aligned
  46                     use buffered I/O to read up to file_aligned
  47                     At that point, if still mem_aligned, use (1)
  48                         else copy into aligned buf and then use (1) */
  49         else if (offset % fd->d_miniosz) {
  50             diff = fd->d_miniosz - (offset % fd->d_miniosz);
  51             diff = ADIOI_MIN(diff, len);
  52             nbytes = pread(fd->fd_sys, buf, diff, offset);
  53 
  54             buf = ((char *) buf) + diff;
  55             offset += diff;
  56             size = len - diff;
  57             if (!(((long) buf) % fd->d_mem)) {
  58                 ADIOI_XFS_Aligned_Mem_File_Read(fd, buf, size, offset, &err);
  59                 nbytes += err;
  60             }
  61             else {
  62                 newbuf = (void *) memalign(XFS_MEMALIGN, size);
  63                 if (newbuf) {
  64                     ADIOI_XFS_Aligned_Mem_File_Read(fd, newbuf, size, offset, &err);
  65                     if (err > 0) memcpy(buf, newbuf, err);
  66                     nbytes += err;
  67                     ADIOI_Free(newbuf);
  68                 }
  69                 else nbytes += pread(fd->fd_sys, buf, size, offset);
  70             }
  71             err = nbytes;
  72         }
  73 
  74         /* (3) if !mem_aligned && file_aligned
  75                     copy into aligned buf, then use (1)  */
  76         else {
  77             newbuf = (void *) memalign(XFS_MEMALIGN, len);
  78             if (newbuf) {
  79                 ADIOI_XFS_Aligned_Mem_File_Read(fd, newbuf, len, offset, &err);
  80                 if (err > 0) memcpy(buf, newbuf, err);
  81                 ADIOI_Free(newbuf);
  82             }
  83             else err = pread(fd->fd_sys, buf, len, offset);
  84         }
  85     }
  86 
  87     if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind += err;
  88 
  89 #ifdef HAVE_STATUS_SET_BYTES
  90     if (err != -1) MPIR_Status_set_bytes(status, datatype, err);
  91 #endif
  92 
  93     if (err == -1) {
  94         *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
  95                                            myname, __LINE__, MPI_ERR_IO, "**io",
  96                                            "**io %s", strerror(errno));
  97     }
  98     else *error_code = MPI_SUCCESS;
  99 }
 100 
 101 
 102 void ADIOI_XFS_Aligned_Mem_File_Read(ADIO_File fd, void *buf, int len, 
 103               ADIO_Offset offset, int *err)
 104 {
 105     int ntimes, rem, newrem, i, size, nbytes;
 106     unsigned read_chunk_sz = fd->hints->fs_hints.xfs.read_chunk_sz;
 107 
 108     /* memory buffer is aligned, offset in file is aligned,
 109        io_size may or may not be of the right size.
 110        use direct I/O to read up to correct io_size,
 111        use buffered I/O for remaining. */
 112 
 113     if (!(len % fd->d_miniosz) && 
 114         (len >= fd->d_miniosz) && (len <= read_chunk_sz))
 115         *err = pread(fd->fd_direct, buf, len, offset);
 116     else if (len < fd->d_miniosz)
 117         *err = pread(fd->fd_sys, buf, len, offset);
 118     else if (len > read_chunk_sz) {
 119         ntimes = len/(read_chunk_sz);
 120         rem = len - ntimes * read_chunk_sz;
 121         nbytes = 0;
 122         for (i=0; i<ntimes; i++) {
 123             nbytes += pread(fd->fd_direct, ((char *)buf) + i * read_chunk_sz,
 124                          read_chunk_sz, offset);
 125             offset += read_chunk_sz;
 126         }
 127         if (rem) {
 128             if (!(rem % fd->d_miniosz))
 129                 nbytes += pread(fd->fd_direct, 
 130                      ((char *)buf) + ntimes * read_chunk_sz, rem, offset);
 131             else {
 132                 newrem = rem % fd->d_miniosz;
 133                 size = rem - newrem;
 134                 if (size) {
 135                     nbytes += pread(fd->fd_direct, 
 136                          ((char *)buf) + ntimes * read_chunk_sz, size, offset);
 137                     offset += size;
 138                 }
 139                 nbytes += pread(fd->fd_sys, 
 140                       ((char *)buf) + ntimes * read_chunk_sz + size, newrem, offset);
 141             }
 142         }
 143         *err = nbytes;
 144     }
 145     else {
 146         rem = len % fd->d_miniosz;
 147         size = len - rem;
 148         nbytes = pread(fd->fd_direct, buf, size, offset);
 149         nbytes += pread(fd->fd_sys, (char *)buf + size, rem, offset+size);
 150         *err = nbytes;
 151     }
 152 }