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   CHECK_FLAGS(fh)
 103   PASS_ZEROCOUNT(count)
 104   smpi_bench_end();
 105   int rank_traced = simgrid::s4u::this_actor::get_pid();
 106   TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - read", count * datatype->size()));
 107   int ret = simgrid::smpi::File::read(fh, buf, count, datatype, status);
 108   TRACE_smpi_comm_out(rank_traced);
 109   smpi_bench_begin();
 110   return ret;
 111 }
 112
 113 int PMPI_File_read_shared(MPI_File fh, void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 114   CHECK_FILE_INPUTS
 115   CHECK_FLAGS(fh)
 116   PASS_ZEROCOUNT(count)
 117   smpi_bench_end();
 118   int rank_traced = simgrid::s4u::this_actor::get_pid();
 119   TRACE_smpi_comm_in(rank_traced, __func__,
 120                      new simgrid::instr::CpuTIData("IO - read_shared", count * datatype->size()));
 121   int ret = simgrid::smpi::File::read_shared(fh, buf, count, datatype, status);
 122   TRACE_smpi_comm_out(rank_traced);
 123   smpi_bench_begin();
 124   return ret;
 125 }
 126
 127 int PMPI_File_write(MPI_File fh, const void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 128   CHECK_FILE_INPUTS
 129   CHECK_FLAGS(fh)
 130   CHECK_RDONLY(fh)
 131   PASS_ZEROCOUNT(count)
 132   smpi_bench_end();
 133   int rank_traced = simgrid::s4u::this_actor::get_pid();
 134   TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - write", count * datatype->size()));
 135   int ret = simgrid::smpi::File::write(fh, const_cast<void*>(buf), count, datatype, status);
 136   TRACE_smpi_comm_out(rank_traced);
 137   smpi_bench_begin();
 138   return ret;
 139 }
 140
 141 int PMPI_File_write_shared(MPI_File fh, const void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 142   CHECK_FILE_INPUTS
 143   CHECK_FLAGS(fh)
 144   CHECK_RDONLY(fh)
 145   PASS_ZEROCOUNT(count)
 146   smpi_bench_end();
 147   int rank_traced = simgrid::s4u::this_actor::get_pid();
 148   TRACE_smpi_comm_in(rank_traced, __func__,
 149                      new simgrid::instr::CpuTIData("IO - write_shared", count * datatype->size()));
 150   int ret = simgrid::smpi::File::write_shared(fh, buf, count, datatype, status);
 151   TRACE_smpi_comm_out(rank_traced);
 152   smpi_bench_begin();
 153   return ret;
 154 }
 155
 156 int PMPI_File_read_all(MPI_File fh, void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 157   CHECK_FILE_INPUTS
 158   CHECK_FLAGS(fh)
 159   smpi_bench_end();
 160   int rank_traced = simgrid::s4u::this_actor::get_pid();
 161   TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - read_all", count * datatype->size()));
 162   int ret = fh->op_all<simgrid::smpi::File::read>(buf, count, datatype, status);
 163   TRACE_smpi_comm_out(rank_traced);
 164   smpi_bench_begin();
 165   return ret;
 166 }
 167
 168 int PMPI_File_read_ordered(MPI_File fh, void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 169   CHECK_FILE_INPUTS
 170   CHECK_FLAGS(fh)
 171   smpi_bench_end();
 172   int rank_traced = simgrid::s4u::this_actor::get_pid();
 173   TRACE_smpi_comm_in(rank_traced, __func__,
 174                      new simgrid::instr::CpuTIData("IO - read_ordered", count * datatype->size()));
 175   int ret = simgrid::smpi::File::read_ordered(fh, buf, count, datatype, status);
 176   TRACE_smpi_comm_out(rank_traced);
 177   smpi_bench_begin();
 178   return ret;
 179 }
 180
 181 int PMPI_File_write_all(MPI_File fh, const void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 182   CHECK_FILE_INPUTS
 183   CHECK_FLAGS(fh)
 184   CHECK_RDONLY(fh)
 185   smpi_bench_end();
 186   int rank_traced = simgrid::s4u::this_actor::get_pid();
 187   TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - write_all", count * datatype->size()));
 188   int ret = fh->op_all<simgrid::smpi::File::write>(const_cast<void*>(buf), count, datatype, status);
 189   TRACE_smpi_comm_out(rank_traced);
 190   smpi_bench_begin();
 191   return ret;
 192 }
 193
 194 int PMPI_File_write_ordered(MPI_File fh, const void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 195   CHECK_FILE_INPUTS
 196   CHECK_FLAGS(fh)
 197   CHECK_RDONLY(fh)
 198   smpi_bench_end();
 199   int rank_traced = simgrid::s4u::this_actor::get_pid();
 200   TRACE_smpi_comm_in(rank_traced, __func__,
 201                      new simgrid::instr::CpuTIData("IO - write_ordered", count * datatype->size()));
 202   int ret = simgrid::smpi::File::write_ordered(fh, buf, count, datatype, status);
 203   TRACE_smpi_comm_out(rank_traced);
 204   smpi_bench_begin();
 205   return ret;
 206 }
 207
 208 int PMPI_File_read_at(MPI_File fh, MPI_Offset offset, void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 209   CHECK_FILE_INPUTS
 210   CHECK_FLAGS(fh)
 211   PASS_ZEROCOUNT(count);
 212   smpi_bench_end();
 213   int rank_traced = simgrid::s4u::this_actor::get_pid();
 214   TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - read", count * datatype->size()));
 215   int ret = fh->seek(offset,MPI_SEEK_SET);
 216   if(ret!=MPI_SUCCESS)
 217     return ret;
 218   ret = simgrid::smpi::File::read(fh, buf, count, datatype, status);
 219   TRACE_smpi_comm_out(rank_traced);
 220   smpi_bench_begin();
 221   return ret;
 222 }
 223
 224 int PMPI_File_read_at_all(MPI_File fh, MPI_Offset offset, void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 225   CHECK_FILE_INPUT_OFFSET
 226   CHECK_FLAGS(fh)
 227   smpi_bench_end();
 228   int rank_traced = simgrid::s4u::this_actor::get_pid();
 229   TRACE_smpi_comm_in(rank_traced, __func__,
 230                      new simgrid::instr::CpuTIData("IO - read_at_all", count * datatype->size()));
 231   int ret = fh->seek(offset,MPI_SEEK_SET);
 232   if(ret!=MPI_SUCCESS)
 233     return ret;
 234   ret = fh->op_all<simgrid::smpi::File::read>(buf, count, datatype, status);
 235   TRACE_smpi_comm_out(rank_traced);
 236   smpi_bench_begin();
 237   return ret;
 238 }
 239
 240 int PMPI_File_write_at(MPI_File fh, MPI_Offset offset, const void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 241   CHECK_FILE_INPUT_OFFSET
 242   CHECK_FLAGS(fh)
 243   CHECK_RDONLY(fh)
 244   PASS_ZEROCOUNT(count);
 245   smpi_bench_end();
 246   int rank_traced = simgrid::s4u::this_actor::get_pid();
 247   TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - write", count * datatype->size()));
 248   int ret = fh->seek(offset,MPI_SEEK_SET);
 249   if(ret!=MPI_SUCCESS)
 250     return ret;
 251   ret = simgrid::smpi::File::write(fh, const_cast<void*>(buf), count, datatype, status);
 252   TRACE_smpi_comm_out(rank_traced);
 253   smpi_bench_begin();
 254   return ret;
 255 }
 256
 257 int PMPI_File_write_at_all(MPI_File fh, MPI_Offset offset, const void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
 258   CHECK_FILE_INPUT_OFFSET
 259   CHECK_FLAGS(fh)
 260   CHECK_RDONLY(fh)
 261   smpi_bench_end();
 262   int rank_traced = simgrid::s4u::this_actor::get_pid();
 263   TRACE_smpi_comm_in(rank_traced, __func__,
 264                      new simgrid::instr::CpuTIData("IO - write_at_all", count * datatype->size()));
 265   int ret = fh->seek(offset,MPI_SEEK_SET);
 266   if(ret!=MPI_SUCCESS)
 267     return ret;
 268   ret = fh->op_all<simgrid::smpi::File::write>(const_cast<void*>(buf), count, datatype, status);
 269   TRACE_smpi_comm_out(rank_traced);
 270   smpi_bench_begin();
 271   return ret;
 272 }
 273
 274 int PMPI_File_delete(const char *filename, MPI_Info info){
 275   if (filename == nullptr)
 276     return MPI_ERR_FILE;
 277   smpi_bench_end();
 278   int ret = simgrid::smpi::File::del(filename, info);
 279   smpi_bench_begin();
 280   return ret;
 281 }
 282
 283 int PMPI_File_get_info(MPI_File  fh, MPI_Info* info)
 284 {
 285   CHECK_FILE(1, fh)
 286   *info = fh->info();
 287   return MPI_SUCCESS;
 288 }
 289
 290 int PMPI_File_set_info(MPI_File  fh, MPI_Info info)
 291 {
 292   CHECK_FILE(1, fh)
 293   fh->set_info(info);
 294   return MPI_SUCCESS;
 295 }
 296
 297 int PMPI_File_get_size(MPI_File  fh, MPI_Offset* size)
 298 {
 299   CHECK_FILE(1, fh)
 300   *size = fh->size();
 301   return MPI_SUCCESS;
 302 }
 303
 304 int PMPI_File_get_amode(MPI_File  fh, int* amode)
 305 {
 306   CHECK_FILE(1, fh)
 307   *amode = fh->flags();
 308   return MPI_SUCCESS;
 309 }
 310
 311 int PMPI_File_get_group(MPI_File  fh, MPI_Group* group)
 312 {
 313   CHECK_FILE(1, fh)
 314   *group = fh->comm()->group();
 315   return MPI_SUCCESS;
 316 }
 317
 318 int PMPI_File_sync(MPI_File  fh)
 319 {
 320   CHECK_FILE(1, fh)
 321   fh->sync();
 322   return MPI_SUCCESS;
 323 }
 324
 325 int PMPI_File_create_errhandler(MPI_File_errhandler_function* function, MPI_Errhandler* errhandler){
 326   *errhandler=new simgrid::smpi::Errhandler(function);
 327   return MPI_SUCCESS;
 328 }
 329
 330 int PMPI_File_get_errhandler(MPI_File file, MPI_Errhandler* errhandler){
 331   if (errhandler==nullptr){
 332     return MPI_ERR_ARG;
 333   } else if (file == MPI_FILE_NULL) {
 334     *errhandler = SMPI_default_File_Errhandler;
 335     return MPI_SUCCESS;
 336   }
 337   *errhandler=file->errhandler();
 338   return MPI_SUCCESS;
 339 }
 340
 341 int PMPI_File_set_errhandler(MPI_File file, MPI_Errhandler errhandler){
 342   if (errhandler==nullptr){
 343     return MPI_ERR_ARG;
 344   } else if (file == MPI_FILE_NULL) {
 345     SMPI_default_File_Errhandler = errhandler;
 346     return MPI_SUCCESS;
 347   }
 348   file->set_errhandler(errhandler);
 349   return MPI_SUCCESS;
 350 }
 351
 352 int PMPI_File_call_errhandler(MPI_File file,int errorcode){
 353   if (file == nullptr) {
 354     return MPI_ERR_WIN;
 355   }
 356   file->errhandler()->call(file, errorcode);
 357   return MPI_SUCCESS;
 358 }