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