src/smpi/bindings/smpi_pmpi_file.cpp

   1 /* Copyright (c) 2007-2021. 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_COUNT(3, count)                                                                                                \
  27   CHECK_TYPE(4, datatype)                                                                                              \
  28   CHECK_BUFFER(2, buf, count, datatype)                                                                                          \
  29
  30 #define CHECK_FILE_INPUT_OFFSET                                                                                        \
  31   CHECK_FILE(1, fh)                                                                                                    \
  32   CHECK_OFFSET(3, offset)                                                                                                 \
  33   CHECK_COUNT(4, count)                                                                                                \
  34   CHECK_TYPE(5, datatype)                                                                                              \
  35   CHECK_BUFFER(2, buf, count, 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   aid_t 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   aid_t 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   aid_t 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   aid_t 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   aid_t 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   aid_t 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   aid_t 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   aid_t 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   aid_t 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     ret = simgrid::smpi::File::read(fh, buf, count, datatype, status);
 213   TRACE_smpi_comm_out(rank_traced);
 214   smpi_bench_begin();
 215   return ret;
 216 }
 217
 218 int PMPI_File_read_at_all(MPI_File fh, MPI_Offset offset, void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 219   CHECK_FILE_INPUT_OFFSET
 220   CHECK_WRONLY(fh)
 221   smpi_bench_end();
 222   aid_t rank_traced = simgrid::s4u::this_actor::get_pid();
 223   TRACE_smpi_comm_in(rank_traced, __func__,
 224                      new simgrid::instr::CpuTIData("IO - read_at_all", count * datatype->size()));
 225   int ret = fh->seek(offset,MPI_SEEK_SET);
 226   if (ret == MPI_SUCCESS)
 227     ret = fh->op_all<simgrid::smpi::File::read>(buf, count, datatype, status);
 228   TRACE_smpi_comm_out(rank_traced);
 229   smpi_bench_begin();
 230   return ret;
 231 }
 232
 233 int PMPI_File_write_at(MPI_File fh, MPI_Offset offset, const void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 234   CHECK_FILE_INPUT_OFFSET
 235   CHECK_RDONLY(fh)
 236   PASS_ZEROCOUNT(count)
 237   smpi_bench_end();
 238   aid_t rank_traced = simgrid::s4u::this_actor::get_pid();
 239   TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - write", count * datatype->size()));
 240   int ret = fh->seek(offset,MPI_SEEK_SET);
 241   if (ret == MPI_SUCCESS)
 242     ret = simgrid::smpi::File::write(fh, const_cast<void*>(buf), count, datatype, status);
 243   TRACE_smpi_comm_out(rank_traced);
 244   smpi_bench_begin();
 245   return ret;
 246 }
 247
 248 int PMPI_File_write_at_all(MPI_File fh, MPI_Offset offset, const void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 249   CHECK_FILE_INPUT_OFFSET
 250   CHECK_RDONLY(fh)
 251   smpi_bench_end();
 252   aid_t rank_traced = simgrid::s4u::this_actor::get_pid();
 253   TRACE_smpi_comm_in(rank_traced, __func__,
 254                      new simgrid::instr::CpuTIData("IO - write_at_all", count * datatype->size()));
 255   int ret = fh->seek(offset,MPI_SEEK_SET);
 256   if (ret == MPI_SUCCESS)
 257     ret = fh->op_all<simgrid::smpi::File::write>(const_cast<void*>(buf), count, datatype, status);
 258   TRACE_smpi_comm_out(rank_traced);
 259   smpi_bench_begin();
 260   return ret;
 261 }
 262
 263 int PMPI_File_delete(const char *filename, MPI_Info info){
 264   if (filename == nullptr)
 265     return MPI_ERR_FILE;
 266   smpi_bench_end();
 267   int ret = simgrid::smpi::File::del(filename, info);
 268   smpi_bench_begin();
 269   return ret;
 270 }
 271
 272 int PMPI_File_set_view(MPI_File fh, MPI_Offset disp, MPI_Datatype etype, MPI_Datatype filetype, const char *datarep, MPI_Info info){
 273   CHECK_FILE(1, fh)
 274   if(not ((fh->flags() & MPI_MODE_SEQUENTIAL) && (disp == MPI_DISPLACEMENT_CURRENT)))
 275     CHECK_OFFSET(2, disp)
 276   CHECK_TYPE(3, etype)
 277   CHECK_TYPE(4, filetype)
 278   smpi_bench_end();
 279   int ret = fh->set_view(disp, etype, filetype, datarep, info);
 280   smpi_bench_begin();
 281   return ret;
 282 }
 283
 284 int PMPI_File_get_view(MPI_File fh, MPI_Offset *disp, MPI_Datatype *etype, MPI_Datatype *filetype, char *datarep){
 285   CHECK_FILE(1, fh)
 286   CHECK_NULL(2, MPI_ERR_ARG, disp)
 287   CHECK_NULL(3, MPI_ERR_ARG, etype)
 288   CHECK_NULL(4, MPI_ERR_ARG, filetype)
 289   smpi_bench_end();
 290   int ret = fh->get_view(disp, etype, filetype, datarep);
 291   smpi_bench_begin();
 292   return ret;
 293 }
 294
 295 int PMPI_File_get_info(MPI_File  fh, MPI_Info* info)
 296 {
 297   CHECK_FILE(1, fh)
 298   *info = new simgrid::smpi::Info(fh->info());
 299   return MPI_SUCCESS;
 300 }
 301
 302 int PMPI_File_set_info(MPI_File  fh, MPI_Info info)
 303 {
 304   CHECK_FILE(1, fh)
 305   fh->set_info(info);
 306   return MPI_SUCCESS;
 307 }
 308
 309 int PMPI_File_get_size(MPI_File  fh, MPI_Offset* size)
 310 {
 311   CHECK_FILE(1, fh)
 312   *size = fh->size();
 313   return MPI_SUCCESS;
 314 }
 315
 316 int PMPI_File_set_size(MPI_File  fh, MPI_Offset size)
 317 {
 318   CHECK_FILE(1, fh)
 319   fh->set_size(size);
 320   return MPI_SUCCESS;
 321 }
 322
 323 int PMPI_File_get_amode(MPI_File  fh, int* amode)
 324 {
 325   CHECK_FILE(1, fh)
 326   *amode = fh->flags();
 327   return MPI_SUCCESS;
 328 }
 329
 330 int PMPI_File_get_group(MPI_File  fh, MPI_Group* group)
 331 {
 332   CHECK_FILE(1, fh)
 333   *group = fh->comm()->group();
 334   return MPI_SUCCESS;
 335 }
 336
 337 int PMPI_File_sync(MPI_File  fh)
 338 {
 339   CHECK_FILE(1, fh)
 340   fh->sync();
 341   return MPI_SUCCESS;
 342 }
 343
 344 int PMPI_File_create_errhandler(MPI_File_errhandler_function* function, MPI_Errhandler* errhandler){
 345   *errhandler=new simgrid::smpi::Errhandler(function);
 346   return MPI_SUCCESS;
 347 }
 348
 349 int PMPI_File_get_errhandler(MPI_File file, MPI_Errhandler* errhandler){
 350   if (errhandler==nullptr){
 351     return MPI_ERR_ARG;
 352   } else if (file == MPI_FILE_NULL) {
 353     *errhandler = SMPI_default_File_Errhandler;
 354     return MPI_SUCCESS;
 355   }
 356   *errhandler=file->errhandler();
 357   return MPI_SUCCESS;
 358 }
 359
 360 int PMPI_File_set_errhandler(MPI_File file, MPI_Errhandler errhandler){
 361   if (errhandler==nullptr){
 362     return MPI_ERR_ARG;
 363   } else if (file == MPI_FILE_NULL) {
 364     SMPI_default_File_Errhandler = errhandler;
 365     return MPI_SUCCESS;
 366   }
 367   file->set_errhandler(errhandler);
 368   return MPI_SUCCESS;
 369 }
 370
 371 int PMPI_File_call_errhandler(MPI_File file,int errorcode){
 372   if (file == nullptr) {
 373     return MPI_ERR_WIN;
 374   }
 375   MPI_Errhandler err = file->errhandler();
 376   err->call(file, errorcode);
 377   simgrid::smpi::Errhandler::unref(err);
 378   return MPI_SUCCESS;
 379 }