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