WrapMPI.h

Go to the documentation of this file.

 
#pragma once
 
#include <limits.h>
#include <stdint.h>
 
#if defined(AUTOPAS_INCLUDE_MPI)
#include <mpi.h>
#else
#include <cstdio>
#include <cstring>
#include <map>
#include <set>
#endif
 
namespace autopas {
 
#if defined(AUTOPAS_INCLUDE_MPI)
 
// MPI_Comm
#define AUTOPAS_MPI_COMM_NULL MPI_COMM_NULL
#define AUTOPAS_MPI_COMM_WORLD MPI_COMM_WORLD
 
// MPI_Datatype
#define AUTOPAS_MPI_BYTE MPI_BYTE
#define AUTOPAS_MPI_CXX_BOOL MPI_CXX_BOOL
#define AUTOPAS_MPI_CHAR MPI_CHAR
#define AUTOPAS_MPI_INT MPI_INT
#define AUTOPAS_MPI_LONG_INT MPI_LONG_INT
#define AUTOPAS_MPI_UNSIGNED_INT MPI_UNSIGNED
#define AUTOPAS_MPI_LONG MPI_LONG
#define AUTOPAS_MPI_UNSIGNED_LONG MPI_UNSIGNED_LONG
#define AUTOPAS_MPI_DOUBLE MPI_DOUBLE
 
// MPI_Op
#define AUTOPAS_MPI_MAX MPI_MAX
#define AUTOPAS_MPI_MIN MPI_MIN
#define AUTOPAS_MPI_SUM MPI_SUM
#define AUTOPAS_MPI_PROD MPI_PROD
#define AUTOPAS_MPI_LAND MPI_LAND
#define AUTOPAS_MPI_BAND MPI_BAND
#define AUTOPAS_MPI_LOR MPI_LOR
#define AUTOPAS_MPI_BOR MPI_BOR
#define AUTOPAS_MPI_LXOR MPI_LXOR
#define AUTOPAS_MPI_BXOR MPI_BXOR
#define AUTOPAS_MPI_MINLOC MPI_MINLOC
#define AUTOPAS_MPI_MAXLOC MPI_MAXLOC
#define AUTOPAS_MPI_REPLACE MPI_REPLACE
#define AUTOPAS_MPI_NO_OP MPI_NO_OP
 
// MPI Constants
#define AUTOPAS_MPI_IN_PLACE MPI_IN_PLACE
 
// MPI_Status
#define AUTOPAS_MPI_STATUS_IGNORE MPI_STATUS_IGNORE
 
// MPI_Request
#define AUTOPAS_MPI_REQUEST_NULL MPI_REQUEST_NULL
 
#define AUTOPAS_MPI_MAX_ERROR_STRING MPI_MAX_ERROR_STRING
 
using AutoPas_MPI_Comm = MPI_Comm;
using AutoPas_MPI_Datatype = MPI_Datatype;
using AutoPas_MPI_Op = MPI_Op;
using AutoPas_MPI_Status = MPI_Status;
using AutoPas_MPI_Request = MPI_Request;
 
#else
 
enum AutoPas_MPI_Comm {
  COMM_NULL = 0,
  COMM_WORLD,
};
#define AUTOPAS_MPI_COMM_NULL autopas::AutoPas_MPI_Comm::COMM_NULL
#define AUTOPAS_MPI_COMM_WORLD autopas::AutoPas_MPI_Comm::COMM_WORLD
 
enum AutoPas_MPI_Datatype {
  BYTE = 1,
  CXX_BOOL = sizeof(bool),
  CHAR = sizeof(char),
  UNSIGNED_CHAR = sizeof(unsigned char),
  UNSIGNED_SHORT = sizeof(unsigned short),
  INT = sizeof(int),
  UNSIGNED_INT = sizeof(unsigned int),
  UNSIGNED_LONG = sizeof(unsigned long),
  UNSIGNED_LONG_LONG = sizeof(unsigned long long),
  LONG = sizeof(double),
  DOUBLE = sizeof(double),
  LONG_INT = sizeof(long) + sizeof(int),
};
// MPI_Datatype
#define AUTOPAS_MPI_BYTE autopas::AutoPas_MPI_Datatype::BYTE
#define AUTOPAS_MPI_CXX_BOOL autopas::AutoPas_MPI_Datatype::CXX_BOOL
#define AUTOPAS_MPI_CHAR autopas::AutoPas_MPI_Datatype::CHAR
#define AUTOPAS_MPI_INT autopas::AutoPas_MPI_Datatype::INT
#define AUTOPAS_MPI_LONG_INT autopas::AutoPas_MPI_Datatype::LONG_INT
#define AUTOPAS_MPI_UNSIGNED_INT autopas::AutoPas_MPI_Datatype::UNSIGNED_INT
#define AUTOPAS_MPI_LONG autopas::AutoPas_MPI_Datatype::LONG
#define AUTOPAS_MPI_UNSIGNED_LONG autopas::AutoPas_MPI_Datatype::UNSIGNED_LONG
#define AUTOPAS_MPI_DOUBLE autopas::AutoPas_MPI_Datatype::DOUBLE
 
enum AutoPas_MPI_Op { MAX, MIN, SUM, PROD, LAND, BAND, LOR, BOR, LXOR, BXOR, MINLOC, MAXLOC, REPLACE, NO_OP };
// MPI_Op
#define AUTOPAS_MPI_MAX autopas::AutoPas_MPI_Op::MAX
#define AUTOPAS_MPI_MIN autopas::AutoPas_MPI_Op::MIN
#define AUTOPAS_MPI_SUM autopas::AutoPas_MPI_Op::SUM
#define AUTOPAS_MPI_PROD autopas::AutoPas_MPI_Op::PROD
#define AUTOPAS_MPI_LAND autopas::AutoPas_MPI_Op::LAND
#define AUTOPAS_MPI_BAND autopas::AutoPas_MPI_Op::BAND
#define AUTOPAS_MPI_LOR autopas::AutoPas_MPI_Op::LOR
#define AUTOPAS_MPI_BOR autopas::AutoPas_MPI_Op::BOR
#define AUTOPAS_MPI_LXOR autopas::AutoPas_MPI_Op::LXOR
#define AUTOPAS_MPI_BXOR autopas::AutoPas_MPI_Op::BXOR
#define AUTOPAS_MPI_MINLOC autopas::AutoPas_MPI_Op::MINLOC
#define AUTOPAS_MPI_MAXLOC autopas::AutoPas_MPI_Op::MAXLOC
#define AUTOPAS_MPI_REPLACE autopas::AutoPas_MPI_Op::REPLACE
#define AUTOPAS_MPI_NO_OP autopas::AutoPas_MPI_Op::NO_OP
 
struct AutoPas_MPI_Status {
  int count, cancelled, AUTOPAS_MPI_SOURCE, AUTOPAS_MPI_TAG, AUTOPAS_MPI_ERROR;
};
#define AUTOPAS_MPI_STATUS_IGNORE nullptr
 
enum AutoPas_MPI_Request {
  REQUEST_NULL,
  COMPLETED_REQUEST,
  INCOMPLETE_REQUEST,
};
#define AUTOPAS_MPI_REQUEST_NULL autopas::AutoPas_MPI_Request::REQUEST_NULL
 
enum AutoPas_MPI_Error {
  AUTOPAS_MPI_SUCCESS = 0,
  AUTOPAS_MPI_ERR_BUFFER,
  AUTOPAS_MPI_ERR_COUNT,
  AUTOPAS_MPI_ERR_TYPE,
  AUTOPAS_MPI_ERR_TAG,
  AUTOPAS_MPI_ERR_COMM,
  AUTOPAS_MPI_ERR_RANK,
  AUTOPAS_MPI_ERR_ROOT,
  AUTOPAS_MPI_ERR_GROUP,
  AUTOPAS_MPI_ERR_OP,
  AUTOPAS_MPI_ERR_TOPOLOGY,
  AUTOPAS_MPI_ERR_DIMS,
  AUTOPAS_MPI_ERR_ARG,
  AUTOPAS_MPI_ERR_UNKNOWN,
  AUTOPAS_MPI_ERR_TRUNCATE,
  AUTOPAS_MPI_ERR_OTHER,
  AUTOPAS_MPI_ERR_INTERN,
  AUTOPAS_MPI_ERR_IN_STATUS,
  AUTOPAS_MPI_ERR_PENDING,
  AUTOPAS_MPI_ERR_REQUEST,
  AUTOPAS_MPI_ERR_LASTCODE,
};
#define AUTOPAS_MPI_MAX_ERROR_STRING 256
#define AUTOPAS_MPI_IN_PLACE ((void *)1)
 
#endif
 
inline int AutoPas_MPI_Init(int *argc, char ***argv);
 
inline int AutoPas_MPI_Finalize();
 
inline int AutoPas_MPI_Finalized(int *flag);
 
inline int AutoPas_MPI_Error_string(int errorcode, char *string, int *resultlen);
 
inline int AutoPas_MPI_Comm_size(AutoPas_MPI_Comm comm, int *size);
 
inline int AutoPas_MPI_Comm_rank(AutoPas_MPI_Comm comm, int *rank);
 
inline int AutoPas_MPI_Comm_dup(AutoPas_MPI_Comm comm, AutoPas_MPI_Comm *newComm);
 
inline int AutoPas_MPI_Comm_free(AutoPas_MPI_Comm *comm);
 
inline int AutoPas_MPI_Send(const void *buf, int count, AutoPas_MPI_Datatype datatype, int dest, int tag,
                            AutoPas_MPI_Comm comm);
 
inline int AutoPas_MPI_Recv(void *buf, int count, AutoPas_MPI_Datatype datatype, int source, int tag,
                            AutoPas_MPI_Comm comm, AutoPas_MPI_Status *status);
 
inline int AutoPas_MPI_Bcast(void *buffer, int count, AutoPas_MPI_Datatype datatype, int root, AutoPas_MPI_Comm comm);
 
inline int AutoPas_MPI_Ibcast(void *buffer, int count, AutoPas_MPI_Datatype datatype, int root, AutoPas_MPI_Comm comm,
                              AutoPas_MPI_Request *request);
inline int AutoPas_MPI_Reduce(const void *sendbuf, void *recvbuf, int count, AutoPas_MPI_Datatype datatype,
                              AutoPas_MPI_Op op, int root, AutoPas_MPI_Comm comm);
 
inline int AutoPas_MPI_Allreduce(const void *sendbuf, void *recvbuf, int count, AutoPas_MPI_Datatype datatype,
                                 AutoPas_MPI_Op op, AutoPas_MPI_Comm comm);
 
inline int AutoPas_MPI_Iallreduce(const void *sendbuf, void *recvbuf, int count, AutoPas_MPI_Datatype datatype,
                                  AutoPas_MPI_Op op, AutoPas_MPI_Comm comm, AutoPas_MPI_Request *request);
 
inline int AutoPas_MPI_Barrier(AutoPas_MPI_Comm comm);
 
inline int AutoPas_MPI_Ibarrier(AutoPas_MPI_Comm comm, AutoPas_MPI_Request *request);
 
inline int AutoPas_MPI_Test(AutoPas_MPI_Request *request, int *flag, AutoPas_MPI_Status *status);
 
inline int AutoPas_MPI_Wait(AutoPas_MPI_Request *request, AutoPas_MPI_Status *status);
 
inline int AutoPas_MPI_Request_free(AutoPas_MPI_Request *request);
 
inline int AutoPas_MPI_Cart_create(AutoPas_MPI_Comm comm, int nDims, const int *dims, const int *periods, int reorder,
                                   AutoPas_MPI_Comm *comm_cart);
 
inline int AutoPas_MPI_Cart_get(AutoPas_MPI_Comm comm, int maxdims, int dims[], int periods[], int coords[]);
 
inline int AutoPas_MPI_Cart_coords(AutoPas_MPI_Comm comm, int rank, int maxdims, int coords[]);
 
inline int AutoPas_MPI_Cart_rank(AutoPas_MPI_Comm comm, const int coords[], int *rank);
 
inline int AutoPas_MPI_Dims_create(int nnodes, int ndims, int dims[]);
 
inline int AutoPas_MPI_Isend(const void *buf, int count, AutoPas_MPI_Datatype datatype, int dest, int tag,
                             AutoPas_MPI_Comm comm, AutoPas_MPI_Request *request);
 
inline int AutoPas_MPI_Irecv(void *buf, int count, AutoPas_MPI_Datatype datatype, int source, int tag,
                             AutoPas_MPI_Comm comm, AutoPas_MPI_Request *request);
inline int AutoPas_MPI_Probe(int source, int tag, AutoPas_MPI_Comm comm, AutoPas_MPI_Status *status);
 
inline int AutoPas_MPI_Get_count(const AutoPas_MPI_Status *status, AutoPas_MPI_Datatype datatype, int *count);
 
inline int AutoPas_MPI_Waitall(int count, AutoPas_MPI_Request array_of_requests[],
                               AutoPas_MPI_Status *array_of_statuses);
 
inline int AutoPas_MPI_Gather(const void *buffer_send, int count_send, AutoPas_MPI_Datatype datatype_send,
                              void *buffer_recv, int count_recv, AutoPas_MPI_Datatype datatype_recv, int root,
                              AutoPas_MPI_Comm comm);
 
inline int AutoPas_MPI_Gatherv(const void *buffer_send, int count_send, AutoPas_MPI_Datatype datatype_send,
                               void *buffer_recv, const int *count_recv, const int *displs,
                               AutoPas_MPI_Datatype datatype_recv, int root, AutoPas_MPI_Comm comm);
inline int AutoPas_MPI_Allgather(void *buffer_send, int count_send, AutoPas_MPI_Datatype datatype_send,
                                 void *buffer_recv, int count_recv, AutoPas_MPI_Datatype datatype_recv,
                                 AutoPas_MPI_Comm comm);
 
inline int AutoPas_MPI_Comm_split(AutoPas_MPI_Comm old_communicator, int color, int key,
                                  AutoPas_MPI_Comm *new_communicator);
 
#if defined(AUTOPAS_INCLUDE_MPI)
 
inline int AutoPas_MPI_Init(int *argc, char ***argv) { return MPI_Init(argc, argv); }
 
inline int AutoPas_MPI_Finalize() { return MPI_Finalize(); }
 
inline int AutoPas_MPI_Finalized(int *flag) { return MPI_Finalized(flag); }
 
inline int AutoPas_MPI_Error_string(int errorcode, char *string, int *resultlen) {
  return MPI_Error_string(errorcode, string, resultlen);
}
 
inline int AutoPas_MPI_Comm_size(AutoPas_MPI_Comm comm, int *size) { return MPI_Comm_size(comm, size); }
 
inline int AutoPas_MPI_Comm_rank(AutoPas_MPI_Comm comm, int *rank) { return MPI_Comm_rank(comm, rank); }
 
inline int AutoPas_MPI_Comm_dup(AutoPas_MPI_Comm comm, AutoPas_MPI_Comm *newComm) {
  return MPI_Comm_dup(comm, newComm);
}
 
inline int AutoPas_MPI_Comm_free(AutoPas_MPI_Comm *comm) { return MPI_Comm_free(comm); }
 
inline int AutoPas_MPI_Comm_split(AutoPas_MPI_Comm comm, int color, int key, AutoPas_MPI_Comm *newcomm) {
  return MPI_Comm_split(comm, color, key, newcomm);
}
 
inline int AutoPas_MPI_Send(const void *buf, int count, AutoPas_MPI_Datatype datatype, int dest, int tag,
                            AutoPas_MPI_Comm comm) {
  return MPI_Send(buf, count, datatype, dest, tag, comm);
}
 
inline int AutoPas_MPI_Recv(void *buf, int count, AutoPas_MPI_Datatype datatype, int source, int tag,
                            AutoPas_MPI_Comm comm, AutoPas_MPI_Status *status) {
  return MPI_Recv(buf, count, datatype, source, tag, comm, status);
}
 
inline int AutoPas_MPI_Bcast(void *buffer, int count, AutoPas_MPI_Datatype datatype, int root, AutoPas_MPI_Comm comm) {
  return MPI_Bcast(buffer, count, datatype, root, comm);
}
 
inline int AutoPas_MPI_Ibcast(void *buffer, int count, AutoPas_MPI_Datatype datatype, int root, AutoPas_MPI_Comm comm,
                              AutoPas_MPI_Request *request) {
  return MPI_Ibcast(buffer, count, datatype, root, comm, request);
}
 
inline int AutoPas_MPI_Reduce(const void *sendbuf, void *recvbuf, int count, AutoPas_MPI_Datatype datatype,
                              AutoPas_MPI_Op op, int root, AutoPas_MPI_Comm comm) {
  return MPI_Reduce(sendbuf, recvbuf, count, datatype, op, root, comm);
}
 
inline int AutoPas_MPI_Allreduce(const void *sendbuf, void *recvbuf, int count, AutoPas_MPI_Datatype datatype,
                                 AutoPas_MPI_Op op, AutoPas_MPI_Comm comm) {
  return MPI_Allreduce(sendbuf, recvbuf, count, datatype, op, comm);
}
 
inline int AutoPas_MPI_Iallreduce(const void *sendbuf, void *recvbuf, int count, AutoPas_MPI_Datatype datatype,
                                  AutoPas_MPI_Op op, AutoPas_MPI_Comm comm, AutoPas_MPI_Request *request) {
  return MPI_Iallreduce(sendbuf, recvbuf, count, datatype, op, comm, request);
}
 
inline int AutoPas_MPI_Barrier(AutoPas_MPI_Comm comm) { return MPI_Barrier(comm); }
 
inline int AutoPas_MPI_Ibarrier(AutoPas_MPI_Comm comm, AutoPas_MPI_Request *request) {
  return MPI_Ibarrier(comm, request);
}
 
inline int AutoPas_MPI_Test(AutoPas_MPI_Request *request, int *flag, AutoPas_MPI_Status *status) {
  return MPI_Test(request, flag, status);
}
 
inline int AutoPas_MPI_Wait(AutoPas_MPI_Request *request, AutoPas_MPI_Status *status) {
  return MPI_Wait(request, status);
}
 
inline int AutoPas_MPI_Request_free(AutoPas_MPI_Request *request) { return MPI_Request_free(request); }
 
inline int AutoPas_MPI_Cart_create(AutoPas_MPI_Comm comm, int nDims, const int *dims, const int *periods, int reorder,
                                   AutoPas_MPI_Comm *comm_cart) {
  return MPI_Cart_create(comm, nDims, dims, periods, reorder, comm_cart);
}
 
inline int AutoPas_MPI_Cart_get(AutoPas_MPI_Comm comm, int maxdims, int dims[], int periods[], int coords[]) {
  return MPI_Cart_get(comm, maxdims, dims, periods, coords);
}
 
inline int AutoPas_MPI_Cart_coords(AutoPas_MPI_Comm comm, int rank, int maxdims, int coords[]) {
  return MPI_Cart_coords(comm, rank, maxdims, coords);
}
 
inline int AutoPas_MPI_Cart_rank(AutoPas_MPI_Comm comm, const int coords[], int *rank) {
  return MPI_Cart_rank(comm, coords, rank);
}
 
inline int AutoPas_MPI_Dims_create(int nnodes, int ndims, int dims[]) { return MPI_Dims_create(nnodes, ndims, dims); }
 
inline int AutoPas_MPI_Isend(const void *buf, int count, AutoPas_MPI_Datatype datatype, int dest, int tag,
                             AutoPas_MPI_Comm comm, AutoPas_MPI_Request *request) {
  return MPI_Isend(buf, count, datatype, dest, tag, comm, request);
}
 
inline int AutoPas_MPI_Irecv(void *buf, int count, AutoPas_MPI_Datatype datatype, int source, int tag,
                             AutoPas_MPI_Comm comm, AutoPas_MPI_Request *request) {
  return MPI_Irecv(buf, count, datatype, source, tag, comm, request);
}
 
inline int AutoPas_MPI_Probe(int source, int tag, AutoPas_MPI_Comm comm, AutoPas_MPI_Status *status) {
  return MPI_Probe(source, tag, comm, status);
}
 
inline int AutoPas_MPI_Get_count(const AutoPas_MPI_Status *status, AutoPas_MPI_Datatype datatype, int *count) {
  return MPI_Get_count(status, datatype, count);
}
 
inline int AutoPas_MPI_Waitall(int count, AutoPas_MPI_Request array_of_requests[],
                               AutoPas_MPI_Status *array_of_statuses) {
  return MPI_Waitall(count, array_of_requests, array_of_statuses);
}
 
inline int AutoPas_MPI_Gather(const void *buffer_send, int count_send, AutoPas_MPI_Datatype datatype_send,
                              void *buffer_recv, int count_recv, AutoPas_MPI_Datatype datatype_recv, int root,
                              AutoPas_MPI_Comm comm) {
  return MPI_Gather(buffer_send, count_send, datatype_send, buffer_recv, count_recv, datatype_recv, root, comm);
}
 
inline int AutoPas_MPI_Gatherv(const void *buffer_send, int count_send, AutoPas_MPI_Datatype datatype_send,
                               void *buffer_recv, const int *count_recv, const int *displs,
                               AutoPas_MPI_Datatype datatype_recv, int root, AutoPas_MPI_Comm comm) {
  return MPI_Gatherv(buffer_send, count_send, datatype_send, buffer_recv, count_recv, displs, datatype_recv, root,
                     comm);
}
 
inline int AutoPas_MPI_Allgather(void *buffer_send, int count_send, AutoPas_MPI_Datatype datatype_send,
                                 void *buffer_recv, int count_recv, AutoPas_MPI_Datatype datatype_recv,
                                 AutoPas_MPI_Comm comm) {
  return MPI_Allgather(buffer_send, count_send, datatype_send, buffer_recv, count_recv, datatype_recv, comm);
}
 
#else
 
inline int AutoPas_MPI_Init(int *argc, char ***argv) { return AUTOPAS_MPI_SUCCESS; }
 
inline int AutoPas_MPI_Finalize() { return AUTOPAS_MPI_SUCCESS; }
 
inline int AutoPas_MPI_Finalized(int *flag) {
  *flag = 1;
  return AUTOPAS_MPI_SUCCESS;
}
 
int AutoPas_MPI_Error_string(int errorcode, char *string, int *resultlen) {
  static const std::map<int, const char *> errorStrings = {
      {AUTOPAS_MPI_SUCCESS, "MPI_SUCCESS: Successful return code"},
      {AUTOPAS_MPI_ERR_BUFFER, "MPI_ERR_BUFFER: Invalid buffer pointer"},
      {AUTOPAS_MPI_ERR_COUNT, "MPI_ERR_COUNT: Invalid count argument"},
      {AUTOPAS_MPI_ERR_TYPE, "MPI_ERR_TYPE: Invalid datatype argument"},
      {AUTOPAS_MPI_ERR_TAG, "MPI_ERR_TAG: Invalid tag argument"},
      {AUTOPAS_MPI_ERR_COMM, "MPI_ERR_COMM: Invalid communicator"},
      {AUTOPAS_MPI_ERR_RANK, "MPI_ERR_RANK: Invalid rank"},
      {AUTOPAS_MPI_ERR_ROOT, "MPI_ERR_ROOT: Invalid root"},
      {AUTOPAS_MPI_ERR_GROUP, "MPI_ERR_GROUP: Null group passed to function"},
      {AUTOPAS_MPI_ERR_OP, "MPI_ERR_OP: Invalid operation"},
      {AUTOPAS_MPI_ERR_TOPOLOGY, "MPI_ERR_TOPOLOGY: Invalid topology"},
      {AUTOPAS_MPI_ERR_DIMS, "MPI_ERR_DIMS: Illegal dimension argument"},
      {AUTOPAS_MPI_ERR_ARG, "MPI_ERR_ARG: Invalid argument"},
      {AUTOPAS_MPI_ERR_UNKNOWN, "MPI_ERR_UNKNOWN: Unknown error"},
      {AUTOPAS_MPI_ERR_TRUNCATE, "MPI_ERR_TRUNCATE: message truncated on receive"},
      {AUTOPAS_MPI_ERR_OTHER, "MPI_ERR_OTHER: Other error; use Error_string"},
      {AUTOPAS_MPI_ERR_INTERN, "MPI_ERR_INTERN: internal error code"},
      {AUTOPAS_MPI_ERR_IN_STATUS, "MPI_ERR_IN_STATUS: Look in status for error value"},
      {AUTOPAS_MPI_ERR_PENDING, "MPI_ERR_PENDING: Pending request"},
      {AUTOPAS_MPI_ERR_REQUEST, "MPI_ERR_REQUEST: illegal mpi_request handle"},
      {AUTOPAS_MPI_ERR_LASTCODE, "MPI_ERR_LASTCODE: Last error code -- always at end"},
  };
  snprintf(string, AUTOPAS_MPI_MAX_ERROR_STRING, "%s", errorStrings.at(errorcode));
  *resultlen = strnlen(string, AUTOPAS_MPI_MAX_ERROR_STRING);
  return AUTOPAS_MPI_SUCCESS;
}
 
inline int AutoPas_MPI_Comm_size(AutoPas_MPI_Comm comm, int *size) {
  if (nullptr == size) {
    return AUTOPAS_MPI_ERR_ARG;
  }
  *size = 1;
  return AUTOPAS_MPI_SUCCESS;
}
 
inline int AutoPas_MPI_Comm_rank(AutoPas_MPI_Comm comm, int *rank) {
  if (nullptr == rank) {
    return AUTOPAS_MPI_ERR_ARG;
  }
  *rank = 0;
  return AUTOPAS_MPI_SUCCESS;
}
 
inline int AutoPas_MPI_Comm_dup(AutoPas_MPI_Comm comm, AutoPas_MPI_Comm *newComm) {
  *newComm = comm;
  return AUTOPAS_MPI_SUCCESS;
}
 
inline int AutoPas_MPI_Comm_free(AutoPas_MPI_Comm *comm) {
  *comm = AUTOPAS_MPI_COMM_NULL;
  return AUTOPAS_MPI_SUCCESS;
}
 
inline int AutoPas_MPI_Send(const void *buf, int count, AutoPas_MPI_Datatype datatype, int dest, int tag,
                            AutoPas_MPI_Comm comm) {
  return AUTOPAS_MPI_SUCCESS;
}
 
inline int AutoPas_MPI_Recv(void *buf, int count, AutoPas_MPI_Datatype datatype, int source, int tag,
                            AutoPas_MPI_Comm comm, AutoPas_MPI_Status *status) {
  // if source==0 there is an error, because you cannot receive from yourself
  // if source >0 there is an error, because there only exists one process
  return AUTOPAS_MPI_ERR_RANK;
}
 
inline int AutoPas_MPI_Bcast(void *buffer, int count, AutoPas_MPI_Datatype datatype, int root, AutoPas_MPI_Comm comm) {
  if (root > 0) {
    return AUTOPAS_MPI_ERR_RANK;
  } else {
    return AUTOPAS_MPI_SUCCESS;
  }
}
 
inline int AutoPas_MPI_Ibcast(void *buffer, int count, AutoPas_MPI_Datatype datatype, int root, AutoPas_MPI_Comm comm,
                              AutoPas_MPI_Request *request) {
  if (root > 0) {
    *request = REQUEST_NULL;
    return AUTOPAS_MPI_ERR_RANK;
  } else {
    *request = COMPLETED_REQUEST;
    return AUTOPAS_MPI_SUCCESS;
  }
}
 
inline int AutoPas_MPI_Reduce(const void *sendbuf, void *recvbuf, int count, AutoPas_MPI_Datatype datatype,
                              AutoPas_MPI_Op op, int root, AutoPas_MPI_Comm comm) {
  if (sendbuf != AUTOPAS_MPI_IN_PLACE) {
    memcpy(recvbuf, sendbuf, datatype * static_cast<size_t>(count));
  }
  return AUTOPAS_MPI_SUCCESS;
}
 
inline int AutoPas_MPI_Allreduce(const void *sendbuf, void *recvbuf, int count, AutoPas_MPI_Datatype datatype,
                                 AutoPas_MPI_Op op, AutoPas_MPI_Comm comm) {
  return AutoPas_MPI_Reduce(sendbuf, recvbuf, count, datatype, op, 0, comm);
}
 
inline int AutoPas_MPI_Iallreduce(const void *sendbuf, void *recvbuf, int count, AutoPas_MPI_Datatype datatype,
                                  AutoPas_MPI_Op op, AutoPas_MPI_Comm comm, AutoPas_MPI_Request *request) {
  *request = COMPLETED_REQUEST;
  return AutoPas_MPI_Allreduce(sendbuf, recvbuf, count, datatype, op, comm);
}
 
inline int AutoPas_MPI_Barrier(AutoPas_MPI_Comm comm) { return AUTOPAS_MPI_SUCCESS; }
 
inline int AutoPas_MPI_Ibarrier(AutoPas_MPI_Comm comm, AutoPas_MPI_Request *request) {
  *request = COMPLETED_REQUEST;
  return AUTOPAS_MPI_SUCCESS;
}
 
inline int AutoPas_MPI_Test(AutoPas_MPI_Request *request, int *flag, AutoPas_MPI_Status *status) {
  *request = REQUEST_NULL;
  *flag = 1;
  return AUTOPAS_MPI_SUCCESS;
}
 
inline int AutoPas_MPI_Wait(AutoPas_MPI_Request *request, AutoPas_MPI_Status *status) {
  *request = REQUEST_NULL;
  return AUTOPAS_MPI_SUCCESS;
}
 
inline int AutoPas_MPI_Request_free(AutoPas_MPI_Request *request) {
  if (*request != COMPLETED_REQUEST) {
    return AUTOPAS_MPI_ERR_REQUEST;
  } else {
    *request = REQUEST_NULL;
    return AUTOPAS_MPI_SUCCESS;
  }
}
 
inline int AutoPas_MPI_Gather(const void *buffer_send, int count_send, AutoPas_MPI_Datatype datatype_send,
                              void *buffer_recv, int count_recv, AutoPas_MPI_Datatype datatype_recv, int root,
                              AutoPas_MPI_Comm comm) {
  // in the non-MPI case this is equivalent to Allgather since there should be only one rank
  if (root != 0) {
    return AUTOPAS_MPI_ERR_ROOT;
  }
  // if MPI_IN_PLACE is passed nothing has to be done since everything is already in the receive buffer.
  if (buffer_send != AUTOPAS_MPI_IN_PLACE) {
    for (long i = 0; i < (count_recv / count_send); i++)
      // offsets from pointers are of type ptrdiff_t which is an alias for long. Hence, i should be long.
      memcpy(static_cast<char *>(buffer_recv) + (i * count_send * sizeof(datatype_send)), buffer_send,
             count_send * sizeof(datatype_send));
  }
  return AUTOPAS_MPI_SUCCESS;
}
 
inline int AutoPas_MPI_Gatherv(const void *buffer_send, int count_send, AutoPas_MPI_Datatype datatype_send,
                               void *buffer_recv, const int *count_recv, const int *displs,
                               AutoPas_MPI_Datatype datatype_recv, int root, AutoPas_MPI_Comm comm) {
  return AutoPas_MPI_Gather(buffer_send, count_send, datatype_send,
                            // get offset address : receive buffer + displacement[0] * sizeof(receiveType)
                            static_cast<char *>(buffer_recv) + static_cast<std::ptrdiff_t>(displs[0] * datatype_recv),
                            count_recv[0], datatype_recv, root, comm);
}
 
inline int AutoPas_MPI_Allgather(void *buffer_send, int count_send, AutoPas_MPI_Datatype datatype_send,
                                 void *buffer_recv, int count_recv, AutoPas_MPI_Datatype datatype_recv,
                                 AutoPas_MPI_Comm comm) {
  return AutoPas_MPI_Gather(buffer_send, count_send, datatype_send, buffer_recv, count_recv, datatype_recv, 0, comm);
}
 
inline int AutoPas_MPI_Comm_split(AutoPas_MPI_Comm old_communicator, int color, int key,
                                  AutoPas_MPI_Comm *new_communicator) {
  *new_communicator = old_communicator;
  return AUTOPAS_MPI_SUCCESS;
}
 
inline int AutoPas_MPI_Cart_create(AutoPas_MPI_Comm comm, int nDims, const int *dims, const int *periods, int reorder,
                                   AutoPas_MPI_Comm *comm_cart) {
  *comm_cart = AUTOPAS_MPI_COMM_WORLD;
  return AUTOPAS_MPI_SUCCESS;
}
 
inline int AutoPas_MPI_Cart_get(AutoPas_MPI_Comm comm, int maxdims, int dims[], int periods[], int coords[]) {
  return AUTOPAS_MPI_SUCCESS;
}
 
inline int AutoPas_MPI_Cart_coords(AutoPas_MPI_Comm comm, int rank, int maxdims, int coords[]) {
  for (int i = 0; i < maxdims; ++i) {
    coords[i] = 0;
  }
  return AUTOPAS_MPI_SUCCESS;
}
 
inline int AutoPas_MPI_Cart_rank(AutoPas_MPI_Comm comm, const int coords[], int *rank) {
  *rank = 0;
  return AUTOPAS_MPI_SUCCESS;
}
 
inline int AutoPas_MPI_Dims_create(int nnodes, int ndims, int dims[]) {
  // in non-MPI case nnodes should always be 1. Therefore there is one rank in every dim.
  for (int i = 0; i < ndims; ++i) {
    dims[i] = 1;
  }
  return AUTOPAS_MPI_SUCCESS;
}
 
inline int AutoPas_MPI_Isend(const void *buf, int count, AutoPas_MPI_Datatype datatype, int dest, int tag,
                             AutoPas_MPI_Comm comm, AutoPas_MPI_Request *request) {
  return AUTOPAS_MPI_SUCCESS;
}
 
inline int AutoPas_MPI_Irecv(void *buf, int count, AutoPas_MPI_Datatype datatype, int source, int tag,
                             AutoPas_MPI_Comm comm, AutoPas_MPI_Request *request) {
  return AUTOPAS_MPI_SUCCESS;
}
 
inline int AutoPas_MPI_Probe(int source, int tag, AutoPas_MPI_Comm comm, AutoPas_MPI_Status *status) {
  return AUTOPAS_MPI_SUCCESS;
}
 
inline int AutoPas_MPI_Get_count(const AutoPas_MPI_Status *status, AutoPas_MPI_Datatype datatype, int *count) {
  *count = 0;
  return AUTOPAS_MPI_SUCCESS;
}
 
inline int AutoPas_MPI_Waitall(int count, AutoPas_MPI_Request array_of_requests[],
                               AutoPas_MPI_Status *array_of_statuses) {
  return AUTOPAS_MPI_SUCCESS;
}
#endif
}  // namespace autopas