parUtils.h

Go to the documentation of this file.

 
#ifndef __PAR_UTILS_H_
#define __PAR_UTILS_H_
 
#define KEEP_HIGH 100
#define KEEP_LOW  101
 
#ifdef __DEBUG__
#ifndef __DEBUG_PAR__
#define __DEBUG_PAR__
#endif
#endif
 
#include "mpi.h"
#include <vector>
 
#ifdef __USE_64_BIT_INT__
#define DendroIntL long long
#define DendroIntLSpecifier %lld
#define DendroUIntLSpecifier %llu
#else
#define DendroIntL int
#define DendroIntLSpecifier %d
#define DendroUIntLSpecifier %u
#endif
 
namespace par {
 
  template <typename T>
    int Mpi_Isend(T* buf, int count, int dest, int tag, MPI_Comm comm, MPI_Request* request);
 
  template <typename T>
    int Mpi_Issend(T* buf, int count, int dest, int tag, MPI_Comm comm, MPI_Request* request);
 
  template <typename T>
    int Mpi_Recv(T* buf, int count, int source, int tag, MPI_Comm comm, MPI_Status* status);
 
  template <typename T>
    int Mpi_Irecv(T* buf, int count, int source, int tag, MPI_Comm comm, MPI_Request* request);
 
  template <typename T>
    int Mpi_Gather( T* sendBuffer, T* recvBuffer, int count, int root, MPI_Comm comm);
 
  template <typename T, typename S>
    int Mpi_Sendrecv( T* sendBuf, int sendCount, int dest, int sendTag,
        S* recvBuf, int recvCount, int source, int recvTag,
        MPI_Comm comm, MPI_Status* status);
 
  template <typename T>
    int Mpi_Bcast( T* buffer, int count, int root, MPI_Comm comm);
 
  template <typename T>
    int Mpi_Scan( T* sendbuf, T* recvbuf, int count, MPI_Op op, MPI_Comm comm);
 
  template <typename T>
    int Mpi_Reduce( T* sendbuf, T* recvbuf, int count, MPI_Op op, int root, MPI_Comm comm);
 
  template <typename T> 
    int Mpi_Allreduce( T* sendbuf, T* recvbuf, int count, MPI_Op op, MPI_Comm comm);
 
  template <typename T>
    int Mpi_Alltoall(T* sendbuf, T* recvbuf, int count, MPI_Comm comm); 
 
  template <typename T>
    int Mpi_Allgatherv(T* sendbuf, int sendcount, T* recvbuf,
        int* recvcounts, int* displs, MPI_Comm comm);
 
  template <typename T>
    int Mpi_Allgather(T* sendbuf, T* recvbuf, int count, MPI_Comm comm);
 
  template <typename T>
    int Mpi_Alltoallv_sparse(T* sendbuf, int* sendcnts, int* sdispls, 
        T* recvbuf, int* recvcnts, int* rdispls, MPI_Comm comm);
 
  template <typename T>
    int Mpi_Alltoallv_dense(T* sendbuf, int* sendcnts, int* sdispls, 
        T* recvbuf, int* recvcnts, int* rdispls, MPI_Comm comm);
  
    
    template<typename T>
    unsigned int defaultWeight(const T *a);
    
  template<typename T>
    int partitionW(std::vector<T>& vec,
        unsigned int (*getWeight)(const T *), MPI_Comm comm);
 
 
        template<typename T>
        void rankSamples(std::vector<T>& arr, std::vector<T> samples, MPI_Comm comm);
 
    template<typename T>
        std::vector<T> Sorted_Sample_Select(std::vector<T>& arr, unsigned int kway, std::vector<unsigned int>& min_idx, std::vector<unsigned int>& max_idx, std::vector<DendroIntL>& splitter_ranks, MPI_Comm comm);
    template<typename T>
        std::vector<T> Sorted_approx_Select(std::vector<T>& arr, unsigned int k, MPI_Comm comm);
  template<typename T>
        std::vector<std::pair<T, DendroIntL> > Sorted_approx_Select_skewed(std::vector<T>& arr, unsigned int k, MPI_Comm comm);
    
  template<typename T>
        std::vector<T> GetRangeMean(std::vector<T>& arr, std::vector<unsigned int> range_min, std::vector<unsigned int> range_max, MPI_Comm comm);
    template<typename T>
        std::vector<T> GuessRangeMedian(std::vector<T>& arr, std::vector<unsigned int> range_min, std::vector<unsigned int> range_max, MPI_Comm comm);
 
        template<typename T>
                std::vector<T> Sorted_k_Select(std::vector<T>& arr, std::vector<unsigned int> min_idx, std::vector<unsigned int> max_idx, std::vector<DendroIntL> K, std::vector<T> guess, MPI_Comm comm);
    
  template<typename T>
    int HyperQuickSort(std::vector<T>& in, std::vector<T> & out, MPI_Comm comm); 
 
  template<typename T>
    int HyperQuickSort_kway(std::vector<T>& in, std::vector<T> & out, MPI_Comm comm); 
  
  template<typename T>
    int HyperQuickSort_cav(std::vector<T>& in, std::vector<T> & out, MPI_Comm comm); 
        
  /* mem-efficient version */
  template<typename T>
    int HyperQuickSort(std::vector<T>& arr, MPI_Comm comm);
        
  template<typename T>
    int HyperQuickSort_kway(std::vector<T>& in, MPI_Comm comm); 
  
  template<typename T>
    int HyperQuickSort_cav(std::vector<T>& in, MPI_Comm comm); 
  
  template<typename T>
    int sampleSort(std::vector<T>& in, std::vector<T> & out, MPI_Comm comm); 
 
  template<typename T>
    int sampleSort(std::vector<T>& in, MPI_Comm comm); 
 
  int splitComm2way(bool iAmEmpty, MPI_Comm* new_comm, MPI_Comm orig_comm);
 
  int splitComm2way(const bool* isEmptyList, MPI_Comm* new_comm, MPI_Comm orig_comm);
 
  /*
     @author Rahul Sampath
     @brief Splits a communication group into two, processors with 
     ranks less than splittingRank form one group and the other 
     processors form the second group. Both the groups are sorted in 
     the ascending order of their ranks in the old comm.
     @param splittingRank The rank used for splitting the communicator
     @param orig_comm    The comm group that needs to be split.
     @param new_comm     The new comm group.
     */
  int splitCommUsingSplittingRank(int splittingRank, MPI_Comm* new_comm, MPI_Comm orig_comm);
 
  unsigned int splitCommBinary( MPI_Comm orig_comm, MPI_Comm* new_comm);
 
 
  unsigned int splitCommBinaryNoFlip( MPI_Comm orig_comm, MPI_Comm* new_comm);
 
  template <typename T>
    void MergeLists( std::vector<T> &listA, std::vector<T> &listB, int KEEP_WHAT) ;
 
  template <typename T>
    void MergeSplit( std::vector<T> &local_list, int which_keys, int partner, MPI_Comm  comm);
 
  template <typename T>
    void Par_bitonic_sort_incr( std::vector<T> &local_list, int proc_set_size, MPI_Comm  comm );
 
  template <typename T>
    void Par_bitonic_sort_decr( std::vector<T> &local_list, int proc_set_size, MPI_Comm  comm);
 
  template <typename T>
    void Par_bitonic_merge_incr( std::vector<T> &local_list, int proc_set_size, MPI_Comm  comm );
 
  template <typename T>
    void bitonicSort_binary(std::vector<T> & in, MPI_Comm comm) ;
 
  template <typename T>
    void bitonicSort(std::vector<T> & in, MPI_Comm comm) ;
 
}//end namespace
 
#include "parUtils.tcc"
 
#endif