root/ompi/mca/io/romio321/romio/adio/ad_lustre/ad_lustre_rwcontig.c

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

DEFINITIONS

This source file includes following definitions.
  1. ADIOI_LUSTRE_Aligned_Mem_File_Write
  2. ADIOI_LUSTRE_Aligned_Mem_File_Read
  3. ADIOI_LUSTRE_Directio
  4. ADIOI_LUSTRE_IOContig
  5. ADIOI_LUSTRE_WriteContig
  6. ADIOI_LUSTRE_ReadContig

   1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
   2 /*
   3  *   Copyright (C) 1997 University of Chicago.
   4  *   See COPYRIGHT notice in top-level directory.
   5  *
   6  *   Copyright (C) 2007 Oak Ridge National Laboratory
   7  *
   8  *   Copyright (C) 2008 Sun Microsystems, Lustre group
   9  */
  10 
  11 #include <unistd.h>
  12 
  13 #include <stdlib.h>
  14 #include <malloc.h>
  15 #include "ad_lustre.h"
  16 
  17 #define LUSTRE_MEMALIGN (1<<12)  /* to use page_shift */
  18 
  19 static void ADIOI_LUSTRE_Aligned_Mem_File_Write(ADIO_File fd, const void *buf, int len,
  20               ADIO_Offset offset, int *err);
  21 static void ADIOI_LUSTRE_Aligned_Mem_File_Write(ADIO_File fd, const void *buf, int len,
  22               ADIO_Offset offset, int *err)
  23 {
  24     int rem, size, nbytes;
  25     if (!(len % fd->d_miniosz) && (len >= fd->d_miniosz)) {
  26         *err = pwrite(fd->fd_direct, buf, len, offset);
  27     } else if (len < fd->d_miniosz) {
  28         *err = pwrite(fd->fd_sys, buf, len, offset);
  29     } else {
  30         rem = len % fd->d_miniosz;
  31         size = len - rem;
  32         nbytes = pwrite(fd->fd_direct, buf, size, offset);
  33         nbytes += pwrite(fd->fd_sys, ((char *)buf) + size, rem, offset+size);
  34         *err = nbytes;
  35     }
  36 }
  37 
  38 static void ADIOI_LUSTRE_Aligned_Mem_File_Read(ADIO_File fd, const void *buf, int len,
  39               ADIO_Offset offset, int *err);
  40 static void ADIOI_LUSTRE_Aligned_Mem_File_Read(ADIO_File fd, const void *buf, int len,
  41               ADIO_Offset offset, int *err)
  42 {
  43     int rem, size, nbytes;
  44     if (!(len % fd->d_miniosz) && (len >= fd->d_miniosz))
  45         *err = pread(fd->fd_direct, (void *)buf, len, offset);
  46     else if (len < fd->d_miniosz)
  47         *err = pread(fd->fd_sys, (void *)buf, len, offset);
  48     else {
  49         rem = len % fd->d_miniosz;
  50         size = len - rem;
  51         nbytes = pread(fd->fd_direct, (void *)buf, size, offset);
  52         nbytes += pread(fd->fd_sys, ((char *)buf) + size, rem, offset+size);
  53         *err = nbytes;
  54     }
  55 }
  56 
  57 
  58 static int ADIOI_LUSTRE_Directio(ADIO_File fd, const void *buf, int len,
  59                            off_t offset, int rw);
  60 static int ADIOI_LUSTRE_Directio(ADIO_File fd, const void *buf, int len,
  61                            off_t offset, int rw)
  62 {
  63     int err=-1, diff, size=len, nbytes = 0;
  64     void *newbuf;
  65 
  66     if (offset % fd->d_miniosz) {
  67         diff = fd->d_miniosz - (offset % fd->d_miniosz);
  68         diff = ADIOI_MIN(diff, len);
  69         if (rw)
  70             nbytes = pwrite(fd->fd_sys, (void *)buf, diff, offset);
  71         else
  72             nbytes = pread(fd->fd_sys, (void *)buf, diff, offset);
  73         buf = ((char *) buf) + diff;
  74         offset += diff;
  75         size = len - diff;
  76     }
  77 
  78     if (!size) {
  79         return diff;
  80     }
  81 
  82     if (rw) { /* direct I/O enabled */
  83         if (!(((long) buf) % fd->d_mem)) {
  84             ADIOI_LUSTRE_Aligned_Mem_File_Write(fd, buf, size, offset, &err);
  85             nbytes += err;
  86         } else {
  87             newbuf = (void *) memalign(LUSTRE_MEMALIGN, size);
  88             if (newbuf) {
  89                 memcpy(newbuf, buf, size);
  90                 ADIOI_LUSTRE_Aligned_Mem_File_Write(fd, newbuf, size, offset, &err);
  91                 nbytes += err;
  92                 ADIOI_Free(newbuf);
  93             }
  94             else nbytes += pwrite(fd->fd_sys, buf, size, offset);
  95         }
  96         err = nbytes;
  97     } else {       
  98         if (!(((long) buf) % fd->d_mem)) {
  99             ADIOI_LUSTRE_Aligned_Mem_File_Read(fd, buf, size, offset, &err);
 100             nbytes += err;
 101         } else {
 102             newbuf = (void *) memalign(LUSTRE_MEMALIGN, size);
 103             if (newbuf) {
 104                 ADIOI_LUSTRE_Aligned_Mem_File_Read(fd, newbuf, size, offset, &err);
 105                 if (err > 0) memcpy((void *)buf, newbuf, err);
 106                 nbytes += err;
 107                 ADIOI_Free(newbuf);
 108             }
 109             else nbytes += pread(fd->fd_sys, (void *)buf, size, offset);
 110         }
 111         err = nbytes;
 112     }
 113     return err;
 114 }
 115 
 116 static void ADIOI_LUSTRE_IOContig(ADIO_File fd, const void *buf, int count,
 117                    MPI_Datatype datatype, int file_ptr_type,
 118                    ADIO_Offset offset, ADIO_Status *status, 
 119                    int io_mode, int *error_code);
 120 static void ADIOI_LUSTRE_IOContig(ADIO_File fd, const void *buf, int count,
 121                    MPI_Datatype datatype, int file_ptr_type,
 122                    ADIO_Offset offset, ADIO_Status *status, 
 123                    int io_mode, int *error_code)
 124 {
 125     int err=-1;
 126     MPI_Count datatype_size, len;
 127     static char myname[] = "ADIOI_LUSTRE_IOCONTIG";
 128 
 129     MPI_Type_size_x(datatype, &datatype_size);
 130     len = datatype_size * count;
 131 
 132     if (file_ptr_type == ADIO_INDIVIDUAL) {
 133         offset = fd->fp_ind;
 134     }
 135 
 136     if (!(fd->direct_read || fd->direct_write)) {
 137         if (fd->fp_sys_posn != offset) {
 138             err = lseek(fd->fd_sys, offset, SEEK_SET);
 139             if (err == -1) goto ioerr;
 140         }
 141         
 142         if (io_mode) {
 143 #ifdef ADIOI_MPE_LOGGING
 144         MPE_Log_event(ADIOI_MPE_write_a, 0, NULL);
 145 #endif
 146             err = write(fd->fd_sys, buf, len);
 147 #ifdef ADIOI_MPE_LOGGING
 148         MPE_Log_event(ADIOI_MPE_write_b, 0, NULL);
 149 #endif
 150         } else {
 151 #ifdef ADIOI_MPE_LOGGING
 152         MPE_Log_event(ADIOI_MPE_read_a, 0, NULL);
 153 #endif
 154             err = read(fd->fd_sys, (void *)buf, len);
 155 #ifdef ADIOI_MPE_LOGGING
 156         MPE_Log_event(ADIOI_MPE_read_b, 0, NULL);
 157 #endif
 158         }
 159     } else {
 160         err = ADIOI_LUSTRE_Directio(fd, buf, len, offset, io_mode);
 161     }
 162 
 163     if (err == -1) goto ioerr;
 164     fd->fp_sys_posn = offset + err;
 165 
 166     if (file_ptr_type == ADIO_INDIVIDUAL) {
 167         fd->fp_ind += err; 
 168     }
 169 
 170 #ifdef HAVE_STATUS_SET_BYTES
 171     if (status) MPIR_Status_set_bytes(status, datatype, err);
 172 #endif
 173     *error_code = MPI_SUCCESS;
 174 
 175 ioerr:
 176     /* --BEGIN ERROR HANDLING-- */
 177     if (err == -1) {
 178         *error_code = MPIO_Err_create_code(MPI_SUCCESS,
 179                                            MPIR_ERR_RECOVERABLE,
 180                                            myname, __LINE__,
 181                                            MPI_ERR_IO, "**io",
 182                                            "**io %s", strerror(errno));
 183         fd->fp_sys_posn = -1;
 184         return;
 185     }
 186     /* --END ERROR HANDLING-- */
 187 }
 188 
 189 void ADIOI_LUSTRE_WriteContig(ADIO_File fd, const void *buf, int count,
 190                    MPI_Datatype datatype, int file_ptr_type,
 191                    ADIO_Offset offset, ADIO_Status *status, int *error_code)
 192 {
 193     ADIOI_LUSTRE_IOContig(fd, buf, count, datatype, file_ptr_type,
 194                    offset, status, 1, error_code);
 195 }
 196 
 197 void ADIOI_LUSTRE_ReadContig(ADIO_File fd, void *buf, int count, 
 198                    MPI_Datatype datatype, int file_ptr_type,
 199                    ADIO_Offset offset, ADIO_Status *status, int *error_code)
 200 {
 201     ADIOI_LUSTRE_IOContig(fd, buf, count, datatype, file_ptr_type,
 202                    offset, status, 0, error_code);
 203 }

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