src/smpi/bindings/smpi_pmpi_file.cpp

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