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