This source file includes following definitions.
- MPI_File_seek_shared
   1 
   2 
   3 
   4 
   5 
   6 
   7 #include "mpioimpl.h"
   8 
   9 #ifdef HAVE_WEAK_SYMBOLS
  10 
  11 #if defined(HAVE_PRAGMA_WEAK)
  12 #pragma weak MPI_File_seek_shared = PMPI_File_seek_shared
  13 #elif defined(HAVE_PRAGMA_HP_SEC_DEF)
  14 #pragma _HP_SECONDARY_DEF PMPI_File_seek_shared MPI_File_seek_shared
  15 #elif defined(HAVE_PRAGMA_CRI_DUP)
  16 #pragma _CRI duplicate MPI_File_seek_shared as PMPI_File_seek_shared
  17 
  18 #elif defined(HAVE_WEAK_ATTRIBUTE)
  19 int MPI_File_seek_shared(MPI_File fh, MPI_Offset offset, int whence) __attribute__((weak,alias("PMPI_File_seek_shared")));
  20 #endif
  21 
  22 
  23 #define MPIO_BUILD_PROFILING
  24 #include "mpioprof.h"
  25 #endif
  26 
  27 
  28 
  29 
  30 
  31 
  32 
  33 
  34 
  35 
  36 
  37 int MPI_File_seek_shared(MPI_File fh, MPI_Offset offset, int whence)
  38 {
  39     int error_code=MPI_SUCCESS, tmp_whence, myrank;
  40     static char myname[] = "MPI_FILE_SEEK_SHARED";
  41     MPI_Offset curr_offset, eof_offset, tmp_offset;
  42     ADIO_File adio_fh;
  43 
  44     ROMIO_THREAD_CS_ENTER();
  45 
  46     adio_fh = MPIO_File_resolve(fh);
  47 
  48     
  49     MPIO_CHECK_FILE_HANDLE(adio_fh, myname, error_code);
  50     MPIO_CHECK_NOT_SEQUENTIAL_MODE(adio_fh, myname, error_code);
  51     MPIO_CHECK_FS_SUPPORTS_SHARED(adio_fh, myname, error_code);
  52     
  53 
  54     tmp_offset = offset;
  55     MPI_Bcast(&tmp_offset, 1, ADIO_OFFSET, 0, adio_fh->comm);
  56     
  57     if (tmp_offset != offset)
  58     {
  59         error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
  60                                           myname, __LINE__, MPI_ERR_ARG,
  61                                           "**notsame", 0);
  62         error_code = MPIO_Err_return_file(adio_fh, error_code);
  63         goto fn_exit;
  64     }
  65     
  66 
  67     tmp_whence = whence;
  68     MPI_Bcast(&tmp_whence, 1, MPI_INT, 0, adio_fh->comm);
  69     
  70     if (tmp_whence != whence)
  71     {
  72         error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
  73                                           myname, __LINE__, MPI_ERR_ARG,
  74                                           "**iobadwhence", 0);
  75         error_code = MPIO_Err_return_file(adio_fh, error_code);
  76         goto fn_exit;
  77     }
  78     
  79 
  80     ADIOI_TEST_DEFERRED(adio_fh, "MPI_File_seek_shared", &error_code);
  81 
  82     MPI_Comm_rank(adio_fh->comm, &myrank);
  83 
  84     if (!myrank)
  85     {
  86         switch(whence)
  87         {
  88         case MPI_SEEK_SET:
  89             
  90             if (offset < 0)
  91             {
  92                 error_code = MPIO_Err_create_code(MPI_SUCCESS,
  93                                                   MPIR_ERR_RECOVERABLE,
  94                                                   myname, __LINE__,
  95                                                   MPI_ERR_ARG,
  96                                                   "**iobadoffset", 0);
  97                 error_code = MPIO_Err_return_file(adio_fh, error_code);
  98                 goto fn_exit;
  99             }
 100             
 101             break;
 102         case MPI_SEEK_CUR:
 103             
 104             ADIO_Get_shared_fp(adio_fh, 0, &curr_offset, &error_code);
 105             
 106             if (error_code != MPI_SUCCESS)
 107             {
 108                 error_code = MPIO_Err_create_code(MPI_SUCCESS,
 109                                                   MPIR_ERR_FATAL,
 110                                                   myname, __LINE__,
 111                                                   MPI_ERR_INTERN, 
 112                                                   "**iosharedfailed", 0);
 113                 error_code = MPIO_Err_return_file(adio_fh, error_code);
 114                 goto fn_exit;
 115             }
 116             
 117             offset += curr_offset;
 118             
 119             if (offset < 0)
 120             {
 121                 error_code = MPIO_Err_create_code(MPI_SUCCESS,
 122                                                   MPIR_ERR_RECOVERABLE,
 123                                                   myname, __LINE__,
 124                                                   MPI_ERR_ARG,
 125                                                   "**ionegoffset", 0);
 126                 error_code = MPIO_Err_return_file(adio_fh, error_code);
 127                 goto fn_exit;
 128             }
 129             
 130             break;
 131         case MPI_SEEK_END:
 132             
 133             ADIOI_Get_eof_offset(adio_fh, &eof_offset);
 134             offset += eof_offset;
 135             
 136             if (offset < 0)
 137             {
 138                 error_code = MPIO_Err_create_code(MPI_SUCCESS,
 139                                                   MPIR_ERR_RECOVERABLE,
 140                                                   myname, __LINE__,
 141                                                   MPI_ERR_ARG,
 142                                                   "**ionegoffset", 0);
 143                 error_code = MPIO_Err_return_file(adio_fh, error_code);
 144                 goto fn_exit;
 145             }
 146             
 147             break;
 148         default:
 149             
 150             error_code = MPIO_Err_create_code(MPI_SUCCESS,
 151                                               MPIR_ERR_RECOVERABLE,
 152                                               myname, __LINE__, MPI_ERR_ARG,
 153                                               "**iobadwhence", 0);
 154             error_code = MPIO_Err_return_file(adio_fh, error_code);
 155             goto fn_exit;
 156             
 157         }
 158 
 159         ADIO_Set_shared_fp(adio_fh, offset, &error_code);
 160         
 161         if (error_code != MPI_SUCCESS)
 162         {
 163             error_code = MPIO_Err_create_code(MPI_SUCCESS,
 164                                               MPIR_ERR_FATAL,
 165                                               myname, __LINE__,
 166                                               MPI_ERR_INTERN, 
 167                                               "**iosharedfailed", 0);
 168             error_code = MPIO_Err_return_file(adio_fh, error_code);
 169             goto fn_exit;
 170         }
 171         
 172 
 173     }
 174 
 175     
 176     MPI_Barrier(adio_fh->comm);
 177 
 178     error_code = MPI_SUCCESS;
 179 
 180 fn_exit:
 181     ROMIO_THREAD_CS_EXIT();
 182 
 183     return error_code;
 184 }