src/smpi/bindings/smpi_pmpi_file.cpp

   1 /* Copyright (c) 2007-2019. The SimGrid Team. All rights reserved.          */
   2
   3 /* This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the license (GNU LGPL) which comes with this package. */
   5
   6 #include "private.hpp"
   7
   8 #include "smpi_file.hpp"
   9 #include "smpi_datatype.hpp"
  10
  11 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(smpi_pmpi);
  12 #define CHECK_FLAGS(fh)                                                                                                \
  13   if ((fh)->flags() & MPI_MODE_SEQUENTIAL)                                                                             \
  14     return MPI_ERR_AMODE;
  15 #define CHECK_RDONLY(fh)                                                                                               \
  16   if ((fh)->flags() & MPI_MODE_RDONLY)                                                                                 \
  17     return MPI_ERR_AMODE;
  18 #define CHECK_WRONLY(fh)                                                                                               \
  19   if ((fh)->flags() & MPI_MODE_WRONLY)                                                                                 \
  20     return MPI_ERR_AMODE;
  21 #define PASS_ZEROCOUNT(count)                                                                                          \
  22   if ((count) == 0) {                                                                                                  \
  23     status->count = 0;                                                                                                 \
  24     return MPI_SUCCESS;                                                                                                \
  25   }
  26
  27 #define CHECK_FILE_INPUTS                                                                                              \
  28   CHECK_FILE(1, fh)                                                                                                    \
  29   CHECK_BUFFER(2, buf, count)                                                                                          \
  30   CHECK_COUNT(3, count)                                                                                                \
  31   CHECK_TYPE(4, datatype)                                                                                              \
  32   CHECK_NULL(5, MPI_ERR_ARG, status)
  33
  34 #define CHECK_FILE_INPUT_OFFSET                                                                                        \
  35   CHECK_FILE(1, fh)                                                                                                    \
  36   CHECK_BUFFER(2, buf, count)                                                                                          \
  37   CHECK_OFFSET(3, offset)                                                                                                 \
  38   CHECK_COUNT(4, count)                                                                                                \
  39   CHECK_TYPE(5, datatype)                                                                                              \
  40   CHECK_NULL(6, MPI_ERR_ARG, status)
  41
  42 extern MPI_Errhandler SMPI_default_File_Errhandler;
  43
  44 int PMPI_File_open(MPI_Comm comm, const char *filename, int amode, MPI_Info info, MPI_File *fh){
  45   CHECK_COMM(1)
  46   CHECK_NULL(2, MPI_ERR_FILE, filename)
  47   if (amode < 0)
  48     return MPI_ERR_AMODE;
  49   smpi_bench_end();
  50   *fh =  new simgrid::smpi::File(comm, filename, amode, info);
  51   smpi_bench_begin();
  52   if ((*fh)->size() != 0 && (amode & MPI_MODE_EXCL)){
  53     delete fh;
  54     return MPI_ERR_AMODE;
  55   }
  56   if(amode & MPI_MODE_APPEND)
  57     (*fh)->seek(0,MPI_SEEK_END);
  58   return MPI_SUCCESS;
  59 }
  60
  61 int PMPI_File_close(MPI_File *fh){
  62   CHECK_NULL(2, MPI_ERR_ARG, fh)
  63   smpi_bench_end();
  64   int ret = simgrid::smpi::File::close(fh);
  65   *fh = MPI_FILE_NULL;
  66   smpi_bench_begin();
  67   return ret;
  68 }
  69
  70 int PMPI_File_seek(MPI_File fh, MPI_Offset offset, int whence){
  71   CHECK_FILE(1, fh)
  72   smpi_bench_end();
  73   int ret = fh->seek(offset,whence);
  74   smpi_bench_begin();
  75   return ret;
  76 }
  77
  78 int PMPI_File_seek_shared(MPI_File fh, MPI_Offset offset, int whence){
  79   CHECK_FILE(1, fh)
  80   smpi_bench_end();
  81   int ret = fh->seek_shared(offset,whence);
  82   smpi_bench_begin();
  83   return ret;
  84 }
  85
  86 int PMPI_File_get_position(MPI_File fh, MPI_Offset* offset){
  87   CHECK_FILE(1, fh)
  88   CHECK_NULL(2, MPI_ERR_DISP, offset)
  89   smpi_bench_end();
  90   int ret = fh->get_position(offset);
  91   smpi_bench_begin();
  92   return ret;
  93 }
  94
  95 int PMPI_File_get_position_shared(MPI_File fh, MPI_Offset* offset){
  96   CHECK_FILE(1, fh)
  97   CHECK_NULL(2, MPI_ERR_DISP, offset)
  98   smpi_bench_end();
  99   int ret = fh->get_position_shared(offset);
 100   smpi_bench_begin();
 101   return ret;
 102 }
 103
 104 int PMPI_File_read(MPI_File fh, void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 105   CHECK_FLAGS(fh)
 106   CHECK_WRONLY(fh)
 107   PASS_ZEROCOUNT(count)
 108   smpi_bench_end();
 109   int rank_traced = simgrid::s4u::this_actor::get_pid();
 110   TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - read", count * datatype->size()));
 111   int ret = simgrid::smpi::File::read(fh, buf, count, datatype, status);
 112   TRACE_smpi_comm_out(rank_traced);
 113   smpi_bench_begin();
 114   return ret;
 115 }
 116
 117 int PMPI_File_read_shared(MPI_File fh, void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 118   CHECK_FILE_INPUTS
 119   CHECK_FLAGS(fh)
 120   CHECK_WRONLY(fh)
 121   PASS_ZEROCOUNT(count)
 122   smpi_bench_end();
 123   int rank_traced = simgrid::s4u::this_actor::get_pid();
 124   TRACE_smpi_comm_in(rank_traced, __func__,
 125                      new simgrid::instr::CpuTIData("IO - read_shared", count * datatype->size()));
 126   int ret = simgrid::smpi::File::read_shared(fh, buf, count, datatype, status);
 127   TRACE_smpi_comm_out(rank_traced);
 128   smpi_bench_begin();
 129   return ret;
 130 }
 131
 132 int PMPI_File_write(MPI_File fh, const void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 133   CHECK_FILE_INPUTS
 134   CHECK_FLAGS(fh)
 135   CHECK_RDONLY(fh)
 136   PASS_ZEROCOUNT(count)
 137   smpi_bench_end();
 138   int rank_traced = simgrid::s4u::this_actor::get_pid();
 139   TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - write", count * datatype->size()));
 140   int ret = simgrid::smpi::File::write(fh, const_cast<void*>(buf), count, datatype, status);
 141   TRACE_smpi_comm_out(rank_traced);
 142   smpi_bench_begin();
 143   return ret;
 144 }
 145
 146 int PMPI_File_write_shared(MPI_File fh, const void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 147   CHECK_FILE_INPUTS
 148   CHECK_FLAGS(fh)
 149   CHECK_RDONLY(fh)
 150   PASS_ZEROCOUNT(count)
 151   smpi_bench_end();
 152   int rank_traced = simgrid::s4u::this_actor::get_pid();
 153   TRACE_smpi_comm_in(rank_traced, __func__,
 154                      new simgrid::instr::CpuTIData("IO - write_shared", count * datatype->size()));
 155   int ret = simgrid::smpi::File::write_shared(fh, buf, count, datatype, status);
 156   TRACE_smpi_comm_out(rank_traced);
 157   smpi_bench_begin();
 158   return ret;
 159 }
 160
 161 int PMPI_File_read_all(MPI_File fh, void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 162   CHECK_FILE_INPUTS
 163   CHECK_FLAGS(fh)
 164   CHECK_WRONLY(fh)
 165   smpi_bench_end();
 166   int rank_traced = simgrid::s4u::this_actor::get_pid();
 167   TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - read_all", count * datatype->size()));
 168   int ret = fh->op_all<simgrid::smpi::File::read>(buf, count, datatype, status);
 169   TRACE_smpi_comm_out(rank_traced);
 170   smpi_bench_begin();
 171   return ret;
 172 }
 173
 174 int PMPI_File_read_ordered(MPI_File fh, void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 175   CHECK_FILE_INPUTS
 176   CHECK_FLAGS(fh)
 177   CHECK_WRONLY(fh)
 178   smpi_bench_end();
 179   int rank_traced = simgrid::s4u::this_actor::get_pid();
 180   TRACE_smpi_comm_in(rank_traced, __func__,
 181                      new simgrid::instr::CpuTIData("IO - read_ordered", count * datatype->size()));
 182   int ret = simgrid::smpi::File::read_ordered(fh, buf, count, datatype, status);
 183   TRACE_smpi_comm_out(rank_traced);
 184   smpi_bench_begin();
 185   return ret;
 186 }
 187
 188 int PMPI_File_write_all(MPI_File fh, const void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 189   CHECK_FILE_INPUTS
 190   CHECK_FLAGS(fh)
 191   CHECK_RDONLY(fh)
 192   smpi_bench_end();
 193   int rank_traced = simgrid::s4u::this_actor::get_pid();
 194   TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - write_all", count * datatype->size()));
 195   int ret = fh->op_all<simgrid::smpi::File::write>(const_cast<void*>(buf), count, datatype, status);
 196   TRACE_smpi_comm_out(rank_traced);
 197   smpi_bench_begin();
 198   return ret;
 199 }
 200
 201 int PMPI_File_write_ordered(MPI_File fh, const void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 202   CHECK_FILE_INPUTS
 203   CHECK_FLAGS(fh)
 204   CHECK_RDONLY(fh)
 205   smpi_bench_end();
 206   int rank_traced = simgrid::s4u::this_actor::get_pid();
 207   TRACE_smpi_comm_in(rank_traced, __func__,
 208                      new simgrid::instr::CpuTIData("IO - write_ordered", count * datatype->size()));
 209   int ret = simgrid::smpi::File::write_ordered(fh, buf, count, datatype, status);
 210   TRACE_smpi_comm_out(rank_traced);
 211   smpi_bench_begin();
 212   return ret;
 213 }
 214
 215 int PMPI_File_read_at(MPI_File fh, MPI_Offset offset, void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 216   CHECK_FILE_INPUTS
 217   CHECK_FLAGS(fh)
 218   CHECK_WRONLY(fh)
 219   PASS_ZEROCOUNT(count);
 220   smpi_bench_end();
 221   int rank_traced = simgrid::s4u::this_actor::get_pid();
 222   TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - read", count * datatype->size()));
 223   int ret = fh->seek(offset,MPI_SEEK_SET);
 224   if(ret!=MPI_SUCCESS)
 225     return ret;
 226   ret = simgrid::smpi::File::read(fh, buf, count, datatype, status);
 227   TRACE_smpi_comm_out(rank_traced);
 228   smpi_bench_begin();
 229   return ret;
 230 }
 231
 232 int PMPI_File_read_at_all(MPI_File fh, MPI_Offset offset, void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 233   CHECK_FILE_INPUT_OFFSET
 234   CHECK_FLAGS(fh)
 235   CHECK_WRONLY(fh)
 236   smpi_bench_end();
 237   int rank_traced = simgrid::s4u::this_actor::get_pid();
 238   TRACE_smpi_comm_in(rank_traced, __func__,
 239                      new simgrid::instr::CpuTIData("IO - read_at_all", count * datatype->size()));
 240   int ret = fh->seek(offset,MPI_SEEK_SET);
 241   if(ret!=MPI_SUCCESS)
 242     return ret;
 243   ret = fh->op_all<simgrid::smpi::File::read>(buf, count, datatype, status);
 244   TRACE_smpi_comm_out(rank_traced);
 245   smpi_bench_begin();
 246   return ret;
 247 }
 248
 249 int PMPI_File_write_at(MPI_File fh, MPI_Offset offset, const void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 250   CHECK_FILE_INPUT_OFFSET
 251   CHECK_FLAGS(fh)
 252   CHECK_RDONLY(fh)
 253   PASS_ZEROCOUNT(count);
 254   smpi_bench_end();
 255   int rank_traced = simgrid::s4u::this_actor::get_pid();
 256   TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - write", count * datatype->size()));
 257   int ret = fh->seek(offset,MPI_SEEK_SET);
 258   if(ret!=MPI_SUCCESS)
 259     return ret;
 260   ret = simgrid::smpi::File::write(fh, const_cast<void*>(buf), count, datatype, status);
 261   TRACE_smpi_comm_out(rank_traced);
 262   smpi_bench_begin();
 263   return ret;
 264 }
 265
 266 int PMPI_File_write_at_all(MPI_File fh, MPI_Offset offset, const void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 267   CHECK_FILE_INPUT_OFFSET
 268   CHECK_FLAGS(fh)
 269   CHECK_RDONLY(fh)
 270   smpi_bench_end();
 271   int rank_traced = simgrid::s4u::this_actor::get_pid();
 272   TRACE_smpi_comm_in(rank_traced, __func__,
 273                      new simgrid::instr::CpuTIData("IO - write_at_all", count * datatype->size()));
 274   int ret = fh->seek(offset,MPI_SEEK_SET);
 275   if(ret!=MPI_SUCCESS)
 276     return ret;
 277   ret = fh->op_all<simgrid::smpi::File::write>(const_cast<void*>(buf), count, datatype, status);
 278   TRACE_smpi_comm_out(rank_traced);
 279   smpi_bench_begin();
 280   return ret;
 281 }
 282
 283 int PMPI_File_delete(const char *filename, MPI_Info info){
 284   if (filename == nullptr)
 285     return MPI_ERR_FILE;
 286   smpi_bench_end();
 287   int ret = simgrid::smpi::File::del(filename, info);
 288   smpi_bench_begin();
 289   return ret;
 290 }
 291
 292 int PMPI_File_get_info(MPI_File  fh, MPI_Info* info)
 293 {
 294   CHECK_FILE(1, fh)
 295   *info = fh->info();
 296   return MPI_SUCCESS;
 297 }
 298
 299 int PMPI_File_set_info(MPI_File  fh, MPI_Info info)
 300 {
 301   CHECK_FILE(1, fh)
 302   fh->set_info(info);
 303   return MPI_SUCCESS;
 304 }
 305
 306 int PMPI_File_get_size(MPI_File  fh, MPI_Offset* size)
 307 {
 308   CHECK_FILE(1, fh)
 309   *size = fh->size();
 310   return MPI_SUCCESS;
 311 }
 312
 313 int PMPI_File_get_amode(MPI_File  fh, int* amode)
 314 {
 315   CHECK_FILE(1, fh)
 316   *amode = fh->flags();
 317   return MPI_SUCCESS;
 318 }
 319
 320 int PMPI_File_get_group(MPI_File  fh, MPI_Group* group)
 321 {
 322   CHECK_FILE(1, fh)
 323   *group = fh->comm()->group();
 324   return MPI_SUCCESS;
 325 }
 326
 327 int PMPI_File_sync(MPI_File  fh)
 328 {
 329   CHECK_FILE(1, fh)
 330   fh->sync();
 331   return MPI_SUCCESS;
 332 }
 333
 334 int PMPI_File_create_errhandler(MPI_File_errhandler_function* function, MPI_Errhandler* errhandler){
 335   *errhandler=new simgrid::smpi::Errhandler(function);
 336   return MPI_SUCCESS;
 337 }
 338
 339 int PMPI_File_get_errhandler(MPI_File file, MPI_Errhandler* errhandler){
 340   if (errhandler==nullptr){
 341     return MPI_ERR_ARG;
 342   } else if (file == MPI_FILE_NULL) {
 343     *errhandler = SMPI_default_File_Errhandler;
 344     return MPI_SUCCESS;
 345   }
 346   *errhandler=file->errhandler();
 347   return MPI_SUCCESS;
 348 }
 349
 350 int PMPI_File_set_errhandler(MPI_File file, MPI_Errhandler errhandler){
 351   if (errhandler==nullptr){
 352     return MPI_ERR_ARG;
 353   } else if (file == MPI_FILE_NULL) {
 354     SMPI_default_File_Errhandler = errhandler;
 355     return MPI_SUCCESS;
 356   }
 357   file->set_errhandler(errhandler);
 358   return MPI_SUCCESS;
 359 }
 360
 361 int PMPI_File_call_errhandler(MPI_File file,int errorcode){
 362   if (file == nullptr) {
 363     return MPI_ERR_WIN;
 364   }
 365   file->errhandler()->call(file, errorcode);
 366   return MPI_SUCCESS;
 367 }