ompi/mca/io/romio321/src/io_romio321_file

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
mca_io_romio321_file_read_at
mca_io_romio321_file_read_at_all
mca_io_romio321_file_iread_at
mca_io_romio321_file_iread_at_all
mca_io_romio321_file_read
mca_io_romio321_file_read_all
mca_io_romio321_file_iread
mca_io_romio321_file_iread_all
mca_io_romio321_file_read_shared
mca_io_romio321_file_iread_shared
mca_io_romio321_file_read_ordered
mca_io_romio321_file_read_at_all_begin
mca_io_romio321_file_read_at_all_end
mca_io_romio321_file_read_all_begin
mca_io_romio321_file_read_all_end
mca_io_romio321_file_read_ordered_begin
mca_io_romio321_file_read_ordered_end
   1 /*
   2  * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
   3  *                         University Research and Technology
   4  *                         Corporation.  All rights reserved.
   5  * Copyright (c) 2004-2005 The University of Tennessee and The University
   6  *                         of Tennessee Research Foundation.  All rights
   7  *                         reserved.
   8  * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
   9  *                         University of Stuttgart.  All rights reserved.
  10  * Copyright (c) 2004-2005 The Regents of the University of California.
  11  *                         All rights reserved.
  12  * Copyright (c) 2017      IBM Corporation.  All rights reserved.
  13  * Copyright (c) 2017      Research Organization for Information Science
  14  *                         and Technology (RIST). All rights reserved.
  15  * $COPYRIGHT$
  16  *
  17  * Additional copyrights may follow
  18  *
  19  * $HEADER$
  20  */
  21 
  22 #include "ompi_config.h"
  23 #include "mpi.h"
  24 #include "ompi/file/file.h"
  25 #include "io_romio321.h"
  26 
  27 
  28 int
  29 mca_io_romio321_file_read_at (ompi_file_t *fh,
  30                            MPI_Offset offset,
  31                            void *buf,
  32                            int count,
  33                            struct ompi_datatype_t *datatype,
  34                            ompi_status_public_t * status)
  35 {
  36     int         ret;
  37     mca_io_romio321_data_t *data;
  38 
  39     data = (mca_io_romio321_data_t *) fh->f_io_selected_data;
  40     OPAL_THREAD_LOCK (&mca_io_romio321_mutex);
  41     ret =
  42         ROMIO_PREFIX(MPI_File_read_at) (data->romio_fh, offset, buf, count,
  43                                        datatype, status);
  44     OPAL_THREAD_UNLOCK (&mca_io_romio321_mutex);
  45 
  46     return ret;
  47 }
  48 
  49 
  50 int
  51 mca_io_romio321_file_read_at_all (ompi_file_t *fh,
  52                                MPI_Offset offset,
  53                                void *buf,
  54                                int count,
  55                                struct ompi_datatype_t *datatype,
  56                                ompi_status_public_t * status)
  57 {
  58     int         ret;
  59     mca_io_romio321_data_t *data;
  60 
  61     data = (mca_io_romio321_data_t *) fh->f_io_selected_data;
  62     OPAL_THREAD_LOCK (&mca_io_romio321_mutex);
  63     ret =
  64         ROMIO_PREFIX(MPI_File_read_at_all) (data->romio_fh, offset, buf, count,
  65                                            datatype, status);
  66     OPAL_THREAD_UNLOCK (&mca_io_romio321_mutex);
  67 
  68     return ret;
  69 }
  70 
  71 
  72 int
  73 mca_io_romio321_file_iread_at (ompi_file_t *fh,
  74                             MPI_Offset offset,
  75                             void *buf,
  76                             int count,
  77                             struct ompi_datatype_t *datatype,
  78                             ompi_request_t **request)
  79 {
  80     int ret;
  81     mca_io_romio321_data_t *data;
  82 
  83     data = (mca_io_romio321_data_t *) fh->f_io_selected_data;
  84     OPAL_THREAD_LOCK (&mca_io_romio321_mutex);
  85     ret =
  86         ROMIO_PREFIX(MPI_File_iread_at) (data->romio_fh, offset, buf, count,
  87                                          datatype, request);
  88     OPAL_THREAD_UNLOCK (&mca_io_romio321_mutex);
  89 
  90     return ret;
  91 }
  92 
  93 int
  94 mca_io_romio321_file_iread_at_all (ompi_file_t *fh,
  95                                    MPI_Offset offset,
  96                                    void *buf,
  97                                    int count,
  98                                    struct ompi_datatype_t *datatype,
  99                                    ompi_request_t **request)
 100 {
 101     int         ret;
 102     mca_io_romio321_data_t *data;
 103 
 104     data = (mca_io_romio321_data_t *) fh->f_io_selected_data;
 105     OPAL_THREAD_LOCK (&mca_io_romio321_mutex);
 106     // ----------------------------------------------------
 107     // NOTE: If you upgrade ROMIO, replace this with the actual ROMIO call.
 108     // ----------------------------------------------------
 109     // No support for non-blocking collective I/O operations.
 110     // Fake it with individual non-blocking I/O operations.
 111     // Similar to OMPIO
 112     ret =
 113         ROMIO_PREFIX(MPI_File_iread_at_all) (data->romio_fh, offset, buf, count,
 114                                              datatype, request);
 115     OPAL_THREAD_UNLOCK (&mca_io_romio321_mutex);
 116 
 117     return ret;
 118 }
 119 
 120 
 121 int
 122 mca_io_romio321_file_read (ompi_file_t *fh,
 123                         void *buf,
 124                         int count,
 125                         struct ompi_datatype_t *datatype,
 126                         ompi_status_public_t * status)
 127 {
 128     int         ret;
 129     mca_io_romio321_data_t *data;
 130 
 131     data = (mca_io_romio321_data_t *) fh->f_io_selected_data;
 132     OPAL_THREAD_LOCK (&mca_io_romio321_mutex);
 133     ret =
 134         ROMIO_PREFIX(MPI_File_read) (data->romio_fh, buf, count, datatype,
 135                                     status);
 136     OPAL_THREAD_UNLOCK (&mca_io_romio321_mutex);
 137 
 138     return ret;
 139 }
 140 
 141 
 142 int
 143 mca_io_romio321_file_read_all (ompi_file_t *fh,
 144                             void *buf,
 145                             int count,
 146                             struct ompi_datatype_t *datatype,
 147                             ompi_status_public_t * status)
 148 {
 149     int         ret;
 150     mca_io_romio321_data_t *data;
 151 
 152     data = (mca_io_romio321_data_t *) fh->f_io_selected_data;
 153     OPAL_THREAD_LOCK (&mca_io_romio321_mutex);
 154     ret =
 155         ROMIO_PREFIX(MPI_File_read_all) (data->romio_fh, buf, count, datatype,
 156                                         status);
 157     OPAL_THREAD_UNLOCK (&mca_io_romio321_mutex);
 158 
 159     return ret;
 160 }
 161 
 162 
 163 int
 164 mca_io_romio321_file_iread (ompi_file_t *fh,
 165                          void *buf,
 166                          int count,
 167                          struct ompi_datatype_t *datatype,
 168                          ompi_request_t **request)
 169 {
 170     int ret;
 171     mca_io_romio321_data_t *data;
 172 
 173     data = (mca_io_romio321_data_t *) fh->f_io_selected_data;
 174     OPAL_THREAD_LOCK (&mca_io_romio321_mutex);
 175     ret =
 176         ROMIO_PREFIX(MPI_File_iread) (data->romio_fh, buf, count, datatype,
 177                                       request);
 178     OPAL_THREAD_UNLOCK (&mca_io_romio321_mutex);
 179 
 180     return ret;
 181 }
 182 
 183 int
 184 mca_io_romio321_file_iread_all (ompi_file_t *fh,
 185                                 void *buf,
 186                                 int count,
 187                                 struct ompi_datatype_t *datatype,
 188                                 ompi_request_t **request)
 189 {
 190     int         ret;
 191     mca_io_romio321_data_t *data;
 192 
 193     data = (mca_io_romio321_data_t *) fh->f_io_selected_data;
 194     OPAL_THREAD_LOCK (&mca_io_romio321_mutex);
 195     // ----------------------------------------------------
 196     // NOTE: If you upgrade ROMIO, replace this with the actual ROMIO call.
 197     // ----------------------------------------------------
 198     // No support for non-blocking collective I/O operations.
 199     // Fake it with individual non-blocking I/O operations.
 200     // Similar to OMPIO
 201     ret =
 202         ROMIO_PREFIX(MPI_File_iread_all) (data->romio_fh, buf, count, datatype,
 203                                           request);
 204     OPAL_THREAD_UNLOCK (&mca_io_romio321_mutex);
 205 
 206     return ret;
 207 }
 208 
 209 int
 210 mca_io_romio321_file_read_shared (ompi_file_t *fh,
 211                                void *buf,
 212                                int count,
 213                                struct ompi_datatype_t *datatype,
 214                                ompi_status_public_t * status)
 215 {
 216     int         ret;
 217     mca_io_romio321_data_t *data;
 218 
 219     data = (mca_io_romio321_data_t *) fh->f_io_selected_data;
 220     OPAL_THREAD_LOCK (&mca_io_romio321_mutex);
 221     ret =
 222         ROMIO_PREFIX(MPI_File_read_shared) (data->romio_fh, buf, count,
 223                                             datatype, status);
 224     OPAL_THREAD_UNLOCK (&mca_io_romio321_mutex);
 225 
 226     return ret;
 227 }
 228 
 229 
 230 int
 231 mca_io_romio321_file_iread_shared (ompi_file_t *fh,
 232                                 void *buf,
 233                                 int count,
 234                                 struct ompi_datatype_t *datatype,
 235                                 ompi_request_t **request)
 236 {
 237     int ret;
 238     mca_io_romio321_data_t *data;
 239 
 240     data = (mca_io_romio321_data_t *) fh->f_io_selected_data;
 241     OPAL_THREAD_LOCK (&mca_io_romio321_mutex);
 242     ret =
 243         ROMIO_PREFIX(MPI_File_iread_shared) (data->romio_fh, buf, count,
 244                                              datatype, request);
 245     OPAL_THREAD_UNLOCK (&mca_io_romio321_mutex);
 246 
 247     return ret;
 248 }
 249 
 250 
 251 int
 252 mca_io_romio321_file_read_ordered (ompi_file_t *fh,
 253                                 void *buf,
 254                                 int count,
 255                                 struct ompi_datatype_t *datatype,
 256                                 ompi_status_public_t * status)
 257 {
 258     int         ret;
 259     mca_io_romio321_data_t *data;
 260 
 261     data = (mca_io_romio321_data_t *) fh->f_io_selected_data;
 262     OPAL_THREAD_LOCK (&mca_io_romio321_mutex);
 263     ret =
 264         ROMIO_PREFIX(MPI_File_read_ordered) (data->romio_fh, buf, count,
 265                                              datatype, status);
 266     OPAL_THREAD_UNLOCK (&mca_io_romio321_mutex);
 267 
 268     return ret;
 269 }
 270 
 271 
 272 int
 273 mca_io_romio321_file_read_at_all_begin (ompi_file_t *fh,
 274                                      MPI_Offset offset,
 275                                      void *buf,
 276                                      int count,
 277                                      struct ompi_datatype_t *datatype)
 278 {
 279     int         ret;
 280     mca_io_romio321_data_t *data;
 281 
 282     data = (mca_io_romio321_data_t *) fh->f_io_selected_data;
 283     OPAL_THREAD_LOCK (&mca_io_romio321_mutex);
 284     ret =
 285         ROMIO_PREFIX(MPI_File_read_at_all_begin) (data->romio_fh, offset, buf,
 286                                                  count, datatype);
 287     OPAL_THREAD_UNLOCK (&mca_io_romio321_mutex);
 288 
 289     return ret;
 290 }
 291 
 292 
 293 int
 294 mca_io_romio321_file_read_at_all_end (ompi_file_t *fh,
 295                                    void *buf,
 296                                    ompi_status_public_t * status)
 297 {
 298     int         ret;
 299     mca_io_romio321_data_t *data;
 300 
 301     data = (mca_io_romio321_data_t *) fh->f_io_selected_data;
 302     OPAL_THREAD_LOCK (&mca_io_romio321_mutex);
 303     ret = ROMIO_PREFIX(MPI_File_read_at_all_end) (data->romio_fh, buf, status);
 304     OPAL_THREAD_UNLOCK (&mca_io_romio321_mutex);
 305 
 306     return ret;
 307 }
 308 
 309 
 310 int
 311 mca_io_romio321_file_read_all_begin (ompi_file_t *fh,
 312                                   void *buf,
 313                                   int count,
 314                                   struct ompi_datatype_t *datatype)
 315 {
 316     int         ret;
 317     mca_io_romio321_data_t *data;
 318 
 319     data = (mca_io_romio321_data_t *) fh->f_io_selected_data;
 320     OPAL_THREAD_LOCK (&mca_io_romio321_mutex);
 321     ret =
 322         ROMIO_PREFIX(MPI_File_read_all_begin) (data->romio_fh, buf, count,
 323                                               datatype);
 324     OPAL_THREAD_UNLOCK (&mca_io_romio321_mutex);
 325 
 326     return ret;
 327 }
 328 
 329 
 330 int
 331 mca_io_romio321_file_read_all_end (ompi_file_t *fh,
 332                                 void *buf,
 333                                 ompi_status_public_t * status)
 334 {
 335     int         ret;
 336     mca_io_romio321_data_t *data;
 337 
 338     data = (mca_io_romio321_data_t *) fh->f_io_selected_data;
 339     OPAL_THREAD_LOCK (&mca_io_romio321_mutex);
 340     ret = ROMIO_PREFIX(MPI_File_read_all_end) (data->romio_fh, buf, status);
 341     OPAL_THREAD_UNLOCK (&mca_io_romio321_mutex);
 342 
 343     return ret;
 344 }
 345 
 346 
 347 int
 348 mca_io_romio321_file_read_ordered_begin (ompi_file_t *fh,
 349                                       void *buf,
 350                                       int count,
 351                                       struct ompi_datatype_t *datatype)
 352 {
 353     int         ret;
 354     mca_io_romio321_data_t *data;
 355 
 356     data = (mca_io_romio321_data_t *) fh->f_io_selected_data;
 357     OPAL_THREAD_LOCK (&mca_io_romio321_mutex);
 358     ret =
 359         ROMIO_PREFIX(MPI_File_read_ordered_begin) (data->romio_fh, buf, count,
 360                                                   datatype);
 361     OPAL_THREAD_UNLOCK (&mca_io_romio321_mutex);
 362 
 363     return ret;
 364 }
 365 
 366 
 367 int
 368 mca_io_romio321_file_read_ordered_end (ompi_file_t *fh,
 369                                     void *buf,
 370                                     ompi_status_public_t * status)
 371 {
 372     int         ret;
 373     mca_io_romio321_data_t *data;
 374 
 375     data = (mca_io_romio321_data_t *) fh->f_io_selected_data;
 376     OPAL_THREAD_LOCK (&mca_io_romio321_mutex);
 377     ret = ROMIO_PREFIX(MPI_File_read_ordered_end) (data->romio_fh, buf,
 378                                                    status);
 379     OPAL_THREAD_UNLOCK (&mca_io_romio321_mutex);
 380 
 381     return ret;
 382 }
/* [<][>][^][v][top][bottom][index][help] */
root/ompi/mca/io/romio321/src/io_romio321_file_read.c

DEFINITIONS
