nimble::mpicontext Class Reference

#include <nimble.mpi.mpicontext.h>

Public Member Functions
const MPI_Comm &	get_comm () const
int	get_size () const
int	get_rank () const
	mpicontext ()=default
	mpicontext (MPI_Comm comm)
	mpicontext (const mpicontext &context)=default
	mpicontext (mpicontext &&context)=default
mpicontext &	operator= (const mpicontext &other)=default
mpicontext &	operator= (mpicontext &&other)=default
int	get_root () const
bool	is_root () const
void	send (const std::vector< int > &data, int rank, int tag) const
void	send (std::pair< int *, int > data, int rank, int tag) const
int	recv_count (int rank, int tag) const
int	recv (std::vector< int > &data, int rank, int tag) const
int	recv (int *data, int rank, int tag, int max_buffer_size) const
int	recv_avoid_resize (std::vector< int > &data, int rank, int tag) const
template<class T, class podT>
void	sendpacked (const T &source, int rank, int tag, std::vector< podT > &buffer) const
template<class T, class podT>
void	recvpacked (T &dest, int rank, int tag, std::vector< podT > &buffer) const
template<class T>
void	sendpacked (const T &source, int rank, int tag) const
std::vector< std::vector< int > >	gather (const std::vector< int > &source, int root) const
std::vector< int >	scatter (int root, const std::vector< std::vector< int > > &source) const
template<size_t count>
std::vector< std::array< int, count > >	allgather_to_vector (const std::array< int, count > &values) const
std::vector< int >	allgather_to_vector (int value) const
std::vector< size_t >	allgather_to_vector (size_t value) const
void	gather_send (int value) const
std::vector< int >	gather_recieve (int value) const
template<size_t n>
void	gather_send (const std::array< int, n > &arr) const
template<size_t n>
std::vector< std::array< int, n > >	gather_recieve (const std::array< int, n > &arr) const
void	gather_send (int *data, int size) const
std::vector< int >	gather_recieve (int *data, int size) const
void	bcast (int &value) const
template<size_t count>
void	bcast (std::array< int, count > &arr) const
std::string	catenate_gatherv (const std::string &str) const
std::string	catenate_gatherv_format (const std::string &str, const std::string &_start, const std::string &separator, const std::string &_end) const
const mpicontext &	print (const std::string &s, std::ostream &os=std::cout) const
const mpicontext &	print_formatted (const std::string &s, const std::string &_start, const std::string &separator, const std::string &_end, std::ostream &os=std::cout) const
const mpicontext &	println (const std::string &s, std::ostream &os=std::cout) const
template<class T>
const mpicontext &	print_if_root (const T &s, std::ostream &os=std::cout) const
template<class T>
const mpicontext &	println_if_root (const T &s, std::ostream &os=std::cout) const
void	gatherv_send (const std::vector< int > &ints) const
void	gatherv_recieve (const std::vector< int > &ints, std::vector< int > &dest, const std::vector< int > &counts, const std::vector< int > &displacements) const
void	scatterv_send (const std::vector< int > &ints, const std::vector< int > &counts, const std::vector< int > &displacements, std::vector< int > &dest) const
void	scatterv_recieve (std::vector< int > &dest) const
MPI_Comm	split_by_color (int color) const
MPI_Comm	split_by_color (int color, int key) const
MPI_Comm	split_by_color () const

Constructor & Destructor Documentation

mpicontext() [1/4]

nimble::mpicontext::mpicontext ( )

default

mpicontext() [2/4]

nimble::mpicontext::mpicontext ( MPI_Comm comm )

inline

: rank{get_rank(comm)}, size{get_size(comm)}, comm{comm} {}

mpicontext() [3/4]

nimble::mpicontext::mpicontext ( const mpicontext & context )

default

mpicontext() [4/4]

nimble::mpicontext::mpicontext ( mpicontext && context )

default

Member Function Documentation

allgather_to_vector() [1/3]

template<size_t count>

std::vector< std::array< int, count > > nimble::mpicontext::allgather_to_vector ( const std::array< int, count > & values ) const

inline

  {
    std::vector<std::array<int, count>> buffer(get_size());
    MPI_Allgather(
        values.data(),      /* data being sent */
        (int)values.size(), /* amount of data being sent */
        MPI_INT,            /* Send type */
        buffer.data(),      /* buffer to place revieced data */
        (int)values.size(), /* spacing with which to insert data from buffer */
        MPI_INT,            /* Recieve type */
        get_comm()          /* MPI Comm to use */
    );
    return buffer;
  }

allgather_to_vector() [2/3]

std::vector< int > nimble::mpicontext::allgather_to_vector ( int value ) const

inline

  {
    std::vector<int> buffer(get_size());
    MPI_Allgather(
        &value,        /* data being sent */
        1,             /* amount of data being sent */
        MPI_INT,       /* Send type */
        buffer.data(), /* buffer to place revieced data */
        1,             /* spacing with which to insert data from buffer */
        MPI_INT,       /* Recieve type */
        get_comm()     /* MPI Comm to use */
    );
    return buffer;
  }

allgather_to_vector() [3/3]

std::vector< size_t > nimble::mpicontext::allgather_to_vector ( size_t value ) const

inline

  {
    std::vector<size_t> buffer(get_size());
    if (sizeof(unsigned long) == sizeof(size_t)) {
      MPI_Allgather(
          &value,            /* data being sent */
          1,                 /* amount of data being sent */
          MPI_UNSIGNED_LONG, /* Send type */
          buffer.data(),     /* buffer to place revieced data */
          1,                 /* spacing with which to insert data from buffer */
          MPI_UNSIGNED_LONG, /* Recieve type */
          get_comm()         /* MPI Comm to use */
      );
    } else {
      MPI_Allgather(
          &value,            /* data being sent */
          sizeof(size_t),    /* amount of data being sent */
          MPI_UNSIGNED_CHAR, /* Send type */
          buffer.data(),     /* buffer to place revieced data */
          sizeof(size_t),    /* spacing with which to insert data from buffer */
          MPI_UNSIGNED_CHAR, /* Recieve type */
          get_comm()         /* MPI Comm to use */
      );
    }
    return buffer;
  }

bcast() [1/2]

void nimble::mpicontext::bcast ( int & value ) const

inline

  {
    MPI_Bcast(&value, 1, MPI_INT, this->get_root(), this->get_comm());
  }

bcast() [2/2]

template<size_t count>

void nimble::mpicontext::bcast ( std::array< int, count > & arr ) const

inline

  {
    MPI_Bcast(arr.data(), count, MPI_INT, this->get_root(), this->get_comm());
  }

catenate_gatherv()

std::string nimble::mpicontext::catenate_gatherv ( const std::string & str ) const

inline

  {
    if (is_root()) {
      std::vector<int> counts{gather_recieve(str.size())};
      std::vector<int> displacements(counts.size());
      std::partial_sum(counts.begin(), counts.end() - 1, displacements.begin() + 1);
      std::string dest((size_t)(displacements.back() + counts.back()), ' ');
      MPI_Gatherv(
          str.data(),           /* data being sent */
          str.size(),           /* amount of data being sent */
          MPI_CHAR,             /* type of data being sent */
          &dest[0],             /* destination of data being sent */
          counts.data(),        /* expected amount of data to be recieved from each
                                   rank */
          displacements.data(), /* displacements of revieced data */
          MPI_CHAR,             /* type of data being recieved */
          this->get_root(),     /* root */
          this->get_comm()      /* MPI Comm to use */
      );
      return dest;
    } else {
      gather_send(str.size());
      MPI_Gatherv(
          str.data(), /* data being sent */
          str.size(), /* amount of data being sent */
          MPI_CHAR,   /* type of data being sent */
          nullptr,    /* destination of data being sent */
          nullptr,    /* expected amount of data to be recieved from each rank */
          nullptr,    /* displacements of revieced data */
          MPI_CHAR,   /* type of data being recieved */
          get_root(), /* root */
          get_comm()  /* MPI Comm to use */
      );
      return {};
    }
  }

catenate_gatherv_format()

std::string nimble::mpicontext::catenate_gatherv_format ( const std::string & str, const std::string & _start, const std::string & separator, const std::string & _end ) const

inline

  {
    if (is_root()) {
      std::vector<int> counts{gather_recieve(str.size())};
      std::vector<int> displacements;
      displacements.reserve(counts.size());
      int displacement_accumulator = _start.size();
      int separator_size           = separator.size();
      for (int count : counts) {
        displacements.emplace_back(displacement_accumulator);
        displacement_accumulator += separator_size + count;
      }
      std::string dest((size_t)(displacement_accumulator + _end.size() - separator_size), ' ');
      MPI_Gatherv(
          str.data(),           /* data being sent */
          str.size(),           /* amount of data being sent */
          MPI_CHAR,             /* type of data being sent */
          &dest[0],             /* destination of data being sent */
          counts.data(),        /* expected amount of data to be recieved from each
                                   rank */
          displacements.data(), /* displacements of revieced data */
          MPI_CHAR,             /* type of data being recieved */
          this->get_root(),     /* root */
          this->get_comm()      /* MPI Comm to use */
      );
      std::copy(_start.begin(), _start.end(), &dest[0]);
      for (int i = 0, max = counts.size() - 1; i < max; ++i) {
        int offset = displacements[i] + counts[i];
        std::copy(separator.begin(), separator.end(), &dest[offset]);
      }
      std::copy(_end.begin(), _end.end(), &dest[displacements.back() + counts.back()]);
      return dest;
    } else {
      gather_send(str.size());
      MPI_Gatherv(
          str.data(), /* data being sent */
          str.size(), /* amount of data being sent */
          MPI_CHAR,   /* type of data being sent */
          nullptr,    /* destination of data being sent */
          nullptr,    /* expected amount of data to be recieved from each rank */
          nullptr,    /* displacements of revieced data */
          MPI_CHAR,   /* type of data being recieved */
          get_root(), /* root */
          get_comm()  /* MPI Comm to use */
      );
      return {};
    }
  }

gather()

std::vector< std::vector< int > > nimble::mpicontext::gather ( const std::vector< int > & source, int root ) const

inline

  {
    if (this->get_rank() == root) {
      // Step 1: figure out how much data is going to be incoming from each rank
      std::vector<int> recv_counts(this->get_size());
      int              sendcount = source.size();
      // TO-DO: review documentation at
      // https://www.mpich.org/static/docs/v3.1/www3/MPI_Gather.html
      // https://www.mpich.org/static/docs/v3.1/www3/MPI_Gatherv.html
      // to ensure that the function call is being passed the correct aruments.
      MPI_Gather(&sendcount, 1, MPI_INT, recv_counts.data(), 1, MPI_INT, root, this->comm);
 
      // Step 2: Get data from all ranks as contiguous block of data
      // destination.size() is the sum of the lengths of all incoming arrays.
      std::vector<int> destination(std::accumulate(recv_counts.begin(), recv_counts.end(), 0));
      std::vector<int> displacements(this->get_size(), 0);
      std::partial_sum(recv_counts.begin(), recv_counts.end() - 1, displacements.data() + 1);
      MPI_Gatherv(
          source.data(),
          sendcount,
          MPI_INT,
          destination.data(),
          recv_counts.data(),
          displacements.data(),
          MPI_INT,
          root,
          this->get_comm());
 
      // Step 3: Copy data from a contiguous block into a vector of vectors.
      std::vector<std::vector<int>> result(this->get_size());
      int *                         start_iter = destination.data(), *end_iter = destination.data() + recv_counts[0];
      for (size_t i = 0; i < result.size(); ++i) {
        result[i]  = std::vector<int>(start_iter, end_iter);
        start_iter = end_iter;
        end_iter += recv_counts[i];
      }
      // Return result
      return result;
    } else {
      // Step 1 (see above)
      int sendcount = source.size();
      MPI_Gather(&sendcount, 1, MPI_INT, 0, 0, MPI_INT, root, this->get_comm());
 
      // Step 2 (see above)
      MPI_Gatherv(source.data(), sendcount, MPI_INT, 0, 0, 0, MPI_INT, root, this->get_comm());
 
      // Return empty vector, as only the root rank will recieve incoming data.
      return {};
    }
  }

gather_recieve() [1/3]

template<size_t n>

std::vector< std::array< int, n > > nimble::mpicontext::gather_recieve ( const std::array< int, n > & arr ) const

inline

  {
    std::vector<std::array<int, n>> buffer(get_size());
    MPI_Gather(
        arr.data(),    /* data being sent */
        n,             /* amount of data being sent */
        MPI_INT,       /* Send type */
        buffer.data(), /* buffer to place revieced data */
        n,             /* spacing with which to insert data from buffer */
        MPI_INT,       /* Recieve type */
        get_root(),    /* MPI Comm to use */
        get_comm()     /* rank that acts as root */
    );
    return buffer;
  }

gather_recieve() [2/3]

std::vector< int > nimble::mpicontext::gather_recieve ( int * data, int size ) const

inline

  {
    std::vector<int> buffer(get_size() * size);
    MPI_Gather(
        data,          /* data being sent */
        size,          /* amount of data being sent */
        MPI_INT,       /* Send type */
        buffer.data(), /* buffer to place revieced data */
        size,          /* spacing with which to insert data from buffer */
        MPI_INT,       /* Recieve type */
        get_root(),    /* MPI Comm to use */
        get_comm());   /* rank that acts as root */
    return buffer;
  }

gather_recieve() [3/3]

std::vector< int > nimble::mpicontext::gather_recieve ( int value ) const

inline

  {
    std::vector<int> buffer(get_size());
    MPI_Gather(
        &value,        /* data being sent */
        1,             /* amount of data being sent */
        MPI_INT,       /* Send type */
        buffer.data(), /* buffer to place revieced data */
        1,             /* spacing with which to insert data from buffer */
        MPI_INT,       /* Recieve type */
        get_root(),    /* MPI Comm to use */
        get_comm()     /* rank that acts as root */
    );
    return buffer;
  }

gather_send() [1/3]

template<size_t n>

void nimble::mpicontext::gather_send ( const std::array< int, n > & arr ) const

inline

  {
    MPI_Gather(
        arr.data(), /* data being sent */
        n,          /* amount of data being sent */
        MPI_INT,    /* Send type */
        nullptr,    /* buffer to place revieced data */
        n,          /* spacing with which to insert data from buffer */
        MPI_INT,    /* Recieve type */
        get_root(), /* MPI Comm to use */
        get_comm()  /* rank that acts as root */
    );
  }

gather_send() [2/3]

void nimble::mpicontext::gather_send ( int * data, int size ) const

inline

  {
    MPI_Gather(
        data,       /* data being sent */
        size,       /* amount of data being sent */
        MPI_INT,    /* Send type */
        nullptr,    /* buffer to place revieced data */
        size,       /* spacing with which to insert data from buffer */
        MPI_INT,    /* Recieve type */
        get_root(), /* MPI Comm to use */
        get_comm()  /* rank that acts as root */
    );
  }

gather_send() [3/3]

void nimble::mpicontext::gather_send ( int value ) const

inline

  {
    MPI_Gather(
        &value,     /* data being sent */
        1,          /* amount of data being sent */
        MPI_INT,    /* Send type */
        nullptr,    /* buffer to place revieced data */
        1,          /* spacing with which to insert data from buffer */
        MPI_INT,    /* Recieve type */
        get_root(), /* MPI Comm to use */
        get_comm()  /* rank that acts as root */
    );
  }

gatherv_recieve()

void nimble::mpicontext::gatherv_recieve ( const std::vector< int > & ints, std::vector< int > & dest, const std::vector< int > & counts, const std::vector< int > & displacements ) const

inline

  {
    // See: https://www.open-mpi.org/doc/v2.1/man3/MPI_Gatherv.3.php
    MPI_Gatherv(
        ints.data(),          /* data being sent */
        ints.size(),          /* amount of data being sent */
        MPI_INT,              /* type of data being sent */
        dest.data(),          /* destination of data being sent */
        counts.data(),        /* expected amount of data to be recieved from each rank */
        displacements.data(), /* displacements of revieced data */
        MPI_INT,              /* type of data being recieved */
        this->get_root(),     /* root */
        this->get_comm());    /* MPI Comm to use */
  }

gatherv_send()

void nimble::mpicontext::gatherv_send ( const std::vector< int > & ints ) const

inline

  {
    // See: https://www.open-mpi.org/doc/v2.1/man3/MPI_Gatherv.3.php
    MPI_Gatherv(
        ints.data(), /* data being sent */
        ints.size(), /* amount of data being sent */
        MPI_INT,     /* type of data being sent */
        nullptr,     /* destination of data being sent */
        nullptr,     /* expected amount of data to be recieved from each rank */
        nullptr,     /* displacements of revieced data */
        MPI_INT,     /* type of data being recieved */
        get_root(),  /* root */
        get_comm()); /* MPI Comm to use */
  }

get_comm()

const MPI_Comm & nimble::mpicontext::get_comm ( ) const

inline

  {
    return comm;
  }

get_rank()

int nimble::mpicontext::get_rank ( ) const

inline

  {
    return rank;
  }

get_root()

int nimble::mpicontext::get_root ( ) const

inline

  {
    return 0;
  }

get_size()

int nimble::mpicontext::get_size ( ) const

inline

  {
    return size;
  }

is_root()

bool nimble::mpicontext::is_root ( ) const

inline

  {
    return rank == get_root();
  }

operator=() [1/2]

mpicontext & nimble::mpicontext::operator= ( const mpicontext & other )

default

operator=() [2/2]

mpicontext & nimble::mpicontext::operator= ( mpicontext && other )

default

print()

const mpicontext & nimble::mpicontext::print ( const std::string & s, std::ostream & os = std::cout ) const

inline

  {
    std::string str = catenate_gatherv(s);
    if (is_root()) { os << str; }
    return *this;
  }

print_formatted()

const mpicontext & nimble::mpicontext::print_formatted ( const std::string & s, const std::string & _start, const std::string & separator, const std::string & _end, std::ostream & os = std::cout ) const

inline

  {
    std::string str = catenate_gatherv_format(s, _start, separator, _end);
    if (is_root()) { os << str; }
    return *this;
  }

print_if_root()

template<class T>

const mpicontext & nimble::mpicontext::print_if_root ( const T & s, std::ostream & os = std::cout ) const

inline

  {
    if (is_root()) { os << s; }
    return *this;
  }

println()

const mpicontext & nimble::mpicontext::println ( const std::string & s, std::ostream & os = std::cout ) const

inline

  {
    std::string str = catenate_gatherv(s + "\n");
    if (is_root()) { os << str; }
    return *this;
  }

println_if_root()

template<class T>

const mpicontext & nimble::mpicontext::println_if_root ( const T & s, std::ostream & os = std::cout ) const

inline

  {
    if (is_root()) { os << s << std::endl; }
    return *this;
  }

recv() [1/2]

int nimble::mpicontext::recv ( int * data, int rank, int tag, int max_buffer_size ) const

inline

  {
    MPI_Status recv_status;
    MPI_Recv(data, max_buffer_size, MPI_INT, rank, tag, this->comm, &recv_status);
    int count;
    MPI_Get_count(&recv_status, MPI_INT, &count);
    return count;
  }

recv() [2/2]

int nimble::mpicontext::recv ( std::vector< int > & data, int rank, int tag ) const

inline

  {
    int count = recv_count(rank, tag);
    data.resize(count);
    MPI_Recv(data.data(), count, MPI_INT, rank, tag, this->comm, MPI_STATUS_IGNORE);
    return count;
  }

recv_avoid_resize()

int nimble::mpicontext::recv_avoid_resize ( std::vector< int > & data, int rank, int tag ) const

inline

  {
    int count = recv_count(rank, tag);
    if (count > data.size()) data.resize(count);
    MPI_Recv(data.data(), count, MPI_INT, rank, tag, this->comm, MPI_STATUS_IGNORE);
    return count;
  }

recv_count()

int nimble::mpicontext::recv_count ( int rank, int tag ) const

inline

  {
    int        count = 0;
    MPI_Status recv_status;
    MPI_Probe(rank, tag, this->comm, &recv_status);
    MPI_Get_count(&recv_status, MPI_INT, &count);
    return count;
  }

recvpacked()

template<class T, class podT>

void nimble::mpicontext::recvpacked ( T & dest, int rank, int tag, std::vector< podT > & buffer ) const

inline

  {
    recv_avoid_resize(buffer, rank, tag);
    serialization::unpack(dest, buffer);
  }

scatter()

std::vector< int > nimble::mpicontext::scatter ( int root, const std::vector< std::vector< int > > & source ) const

inline

  {
    if (this->get_rank() == root) {
      // Step 1: notify each rank of how much data they should expect to recieve
      int              recvcount;
      std::vector<int> send_counts(this->get_size());
      for (size_t i = 0; i < send_counts.size(); ++i) { send_counts[i] = source[i].size(); }
      MPI_Scatter(send_counts.data(), 1, MPI_INT, &recvcount, 1, MPI_INT, root, this->get_comm());
 
      // Step 2: send out data to each of the ranks.
      std::vector<int> destination(recvcount, 0);
      std::vector<int> displacements(this->get_size(), 0);
      std::vector<int> source_made_contiguous(std::accumulate(send_counts.begin(), send_counts.end(), 0), 0);
 
      std::partial_sum(send_counts.begin(), send_counts.end() - 1, displacements.data() + 1);
      MPI_Scatterv(
          source.data(),
          send_counts.data(),
          displacements.data(),
          MPI_INT,
          destination.data(),
          recvcount,
          MPI_INT,
          root,
          this->get_comm());
    } else {
      int recvcount;
      MPI_Scatter(0, 0, MPI_INT, &recvcount, 1, MPI_INT, root, this->get_comm());
      std::vector<int> recvbuff(recvcount);
      MPI_Scatterv(0, 0, 0, MPI_INT, recvbuff.data(), recvcount, MPI_INT, root, this->get_comm());
      return recvbuff;
    }
    return std::vector<int>();
  }

scatterv_recieve()

void nimble::mpicontext::scatterv_recieve ( std::vector< int > & dest ) const

inline

  {
    // See: https://www.open-mpi.org/doc/v2.1/man3/MPI_Scatterv.3.php
    MPI_Scatterv(
        nullptr,           /* data being sent */
        nullptr,           /* amount of data being sent to each rank */
        nullptr,           /* displacements of data being sent */
        MPI_INT,           /* type of data being sent */
        dest.data(),       /* place to put sent data */
        dest.size(),       /* amount of data to recieve */
        MPI_INT,           /* type of data being recieved */
        this->get_root(),  /* root sending the data */
        this->get_comm()); /*communicator */
  }

scatterv_send()

void nimble::mpicontext::scatterv_send ( const std::vector< int > & ints, const std::vector< int > & counts, const std::vector< int > & displacements, std::vector< int > & dest ) const

inline

  {
    // See: https://www.open-mpi.org/doc/v2.1/man3/MPI_Scatterv.3.php
    MPI_Scatterv(
        ints.data(),          /* data being sent */
        counts.data(),        /* amount of data being sent to each rank */
        displacements.data(), /* displacements of data being sent */
        MPI_INT,              /* type of data being sent */
        dest.data(),          /* place to put sent data */
        dest.size(),          /* amount of data to recieve */
        MPI_INT,              /* type of data being recieved */
        this->get_root(),     /* root sending the data */
        this->get_comm());    /*communicator */
  }

send() [1/2]

void nimble::mpicontext::send ( const std::vector< int > & data, int rank, int tag ) const

inline

  {
    MPI_Send(data.data(), data.size(), MPI_INT, rank, tag, this->comm);
  }

send() [2/2]

void nimble::mpicontext::send ( std::pair< int *, int > data, int rank, int tag ) const

inline

  {
    MPI_Send(data.first, data.second, MPI_INT, rank, tag, this->comm);
  }

sendpacked() [1/2]

template<class T>

void nimble::mpicontext::sendpacked ( const T & source, int rank, int tag ) const

inline

  {
    int sendcount = serialization::pack_avoid_resize(source, serialization_buffer);
    send({serialization_buffer.data(), sendcount}, rank, tag);
  }

sendpacked() [2/2]

template<class T, class podT>

void nimble::mpicontext::sendpacked ( const T & source, int rank, int tag, std::vector< podT > & buffer ) const

inline

  {
    serialization::pack_avoid_resize(source, buffer);
    send(buffer, rank, tag);
  }

split_by_color() [1/3]

MPI_Comm nimble::mpicontext::split_by_color ( ) const

inline

  {
    return split_by_color(MPI_UNDEFINED);
  }

split_by_color() [2/3]

MPI_Comm nimble::mpicontext::split_by_color ( int color ) const

inline

  {
    return split_by_color(color, this->get_rank());
  }

split_by_color() [3/3]

MPI_Comm nimble::mpicontext::split_by_color ( int color, int key ) const

inline

  {
    MPI_Comm new_comm;
    MPI_Comm_split(get_comm(), color, key, &new_comm);
    return new_comm;
  }

---

The documentation for this class was generated from the following file:

• src/nimble.mpi.mpicontext.h