PC/DistributionBloc.h

Go to the documentation of this file.

#ifndef DISTRIBUTION_BLOC_1D_IS_DEFINED
#define DISTRIBUTION_BLOC_1D_IS_DEFINED

#if defined(__cplusplus)
extern "C" {
#endif  




//    // vOut represents what localData/stopo have to send to nodes of dtopo (vOut[].rank is in dtopo space)
//    void computeSendBlock1D(GlobalData_t* gd, LocalData_t *sd, Topology_t *stopo, Topology_t *dtopo,
//            vector<LocalData_t>* vOut);

//    // vOut represents what localData/dtopo have to receive from nodes of stopo (vOut[].rank is in stopo space)
//    void computeReceiveBlock1D(GlobalData_t* gd, LocalData_t *dd, Topology_t *stopo, Topology_t *dtopo,
//               vector<LocalData_t>* vOut);

//    // vOut represents what localData/stopo have to send to nodes of dtopo (vOut[].rank is in dtopo space)
//    void computeSendRemoteDataBlock1D(GlobalData_t* gd, LocalData_t *sd, Topology_t *stopo, Topology_t *dtopo,
//                 vector<LocalData_t>* vOut, vector<void*> pData, distLoc_t mode,
//                 void *sdata,  void *ddata);



  // Definition of bloc: all but the last one have the same size. The last bloc size
  //                     can be null !

  // Compute BlockSize
  static inline unsigned blockSize(unsigned glen, unsigned total) {
    return (glen+total-1)/total;
  }

  // Compute the size of the block on the processor of rank rank ( == bsz but for the last one)
  static inline unsigned localBlockLengthO(unsigned glen, unsigned rank, unsigned total, unsigned bsz) {
    if (rank == total - 1) {
      return glen - rank * bsz;
    } else {
      return bsz;
    }
  }
  static inline unsigned localBlockLength(unsigned glen, unsigned rank, unsigned total) {
    if (rank == total - 1) {
      return glen - rank * blockSize(glen, total);
    } else {
      return blockSize(glen, total);
    }
  }

  // Compute the bounds low & high of the process of rank rank
  static inline void computeBlockBoundsO(unsigned long *low, unsigned long *high, unsigned glen, 
                unsigned rank, unsigned bsz) {
    unsigned long tmp = (rank+1) * bsz;
    *low =  rank * bsz;    
    *high = ((glen <= tmp)?glen:tmp); // min
  }
  static inline void computeBlockBounds(unsigned *low, unsigned *high, unsigned glen, 
               unsigned rank, unsigned total) {

    unsigned bsz = blockSize(glen, total);
    unsigned tmp = (rank+1) * bsz;

    *low =  rank * bsz;    
    *high = ((glen <= tmp)?glen:tmp); // min
  }

  static inline unsigned computeBlockBoundInf0(unsigned bsz, unsigned rank) {
    return  rank * bsz;
  }

  static inline unsigned computeBlockBoundInf(unsigned glen, unsigned rank, unsigned total) {
    return  computeBlockBoundInf0(rank,blockSize(glen, total));
  }

  static inline unsigned computeBlockBoundSup0(unsigned glen, unsigned bsz, unsigned rank) {
    unsigned tmp = (rank+1) * bsz;
    return ((glen <= tmp)?glen:tmp); // min

  }

  static inline unsigned computeBlockBoundSup(unsigned glen, unsigned rank, unsigned total) {
    unsigned bsz = blockSize(glen, total);
    return computeBlockBoundSup0(glen, bsz, rank);
  }

#if defined(__cplusplus)
}
#endif

#endif