Zoltan2_MachineForTesting.hpp

Go to the documentation of this file.

#ifndef _ZOLTAN2_MACHINEFORTESTING_HPP_
#define _ZOLTAN2_MACHINEFORTESTING_HPP_
 
#include <Teuchos_Comm.hpp>
#include <Teuchos_CommHelpers.hpp>
#include <Zoltan2_Machine.hpp>
 
namespace Zoltan2{

 
template <typename pcoord_t, typename part_t>
class MachineForTesting : public Machine<pcoord_t, part_t> {
 
public:
 
  MachineForTesting(const Teuchos::Comm<int> &comm): 
    Machine<pcoord_t,part_t>(comm),
    networkDim(3),
    procCoords(NULL)
  {
    //allocate memory for processor coordinates.
    procCoords = new pcoord_t *[networkDim];
    for (int i = 0; i < networkDim; ++i){
      procCoords[i] = new pcoord_t[this->numRanks];
      memset(procCoords[i], 0, sizeof(pcoord_t) * this->numRanks);
    }
 
    //obtain the coordinate of the processor.
    pcoord_t *xyz = new pcoord_t[networkDim];
    getMyMachineCoordinate(xyz);
    for (int i = 0; i < networkDim; i++)
      procCoords[i][this->myRank] = xyz[i];
    delete [] xyz;
 
    //reduceAll the coordinates of each processor.
    gatherMachineCoordinates(comm);
  }
 
  MachineForTesting(const Teuchos::Comm<int> &comm, const Teuchos::ParameterList &pl):
    Machine<pcoord_t,part_t>(comm),
    networkDim(3),
    procCoords(NULL)
  {
    //allocate memory for processor coordinates.
    procCoords = new pcoord_t *[networkDim];
    for (int i = 0; i < networkDim; ++i){
      procCoords[i] = new pcoord_t[this->numRanks];
      memset(procCoords[i], 0, sizeof(pcoord_t) * this->numRanks);
    }
 
    //obtain the coordinate of the processor.
    pcoord_t *xyz = new pcoord_t[networkDim];
    getMyMachineCoordinate(xyz);
    for (int i = 0; i < networkDim; i++)
      procCoords[i][this->myRank] = xyz[i];
    delete [] xyz;
 
    //reduceAll the coordinates of each processor.
    gatherMachineCoordinates(comm);
  }
 
  virtual ~MachineForTesting() {
    for (int i = 0; i < networkDim; i++){
      delete [] procCoords[i];
    }
    delete [] procCoords;
  }
 
  bool hasMachineCoordinates() const { return true; }
 
  int getMachineDim() const { return networkDim; }
 
  bool getMachineExtent(int *nxyz) const { 
    // Ficticious machine extent
    nxyz[0] = this->numRanks;
    nxyz[1] = 2*this->numRanks;
    nxyz[2] = 3*this->numRanks;
    return true; 
  }
 
  bool getMyMachineCoordinate(pcoord_t *xyz) {
    return getMachineCoordinate(this->myRank, xyz);
  }
 
  bool getMachineCoordinate(const int rank, pcoord_t *xyz) {
    // Ficticious machine coordinates
    // part_t slice = part_t(pow(double(this->numRanks), double(1.0/networkDim))
    //                           + 0.5);
    // part_t m = rank;
    // for (int i = 0; i < networkDim; ++i){
    //   xyz[i] = m / part_t(pow(slice, double(networkDim - i - 1)));
    //   m = m % part_t(pow(double(slice), double(networkDim - i - 1)));
    // }
 
    xyz[0] = rank;
    xyz[1] = this->numRanks;
    xyz[2] = this->numRanks+1;
    return true;
  }
 
  bool getMachineCoordinate(const char *nodename, pcoord_t *xyz) {
    return false;  // cannot yet return from nodename
  }
 
  bool getAllMachineCoordinatesView(pcoord_t **&allCoords) const {
    allCoords = procCoords;
    return true;
  }
 
private:
 
  int networkDim;
 
  pcoord_t **procCoords;   // KDD Maybe should be RCP?
 
  void gatherMachineCoordinates(const Teuchos::Comm<int> &comm) {  
    // reduces and stores all machine coordinates.
    pcoord_t *tmpVect = new pcoord_t [this->numRanks];
 
    for (int i = 0; i < networkDim; i++) {
      Teuchos::reduceAll<int, pcoord_t>(comm, Teuchos::REDUCE_SUM,
                                        this->numRanks, procCoords[i], tmpVect);
      pcoord_t *tmp = tmpVect;
      tmpVect = procCoords[i];
      procCoords[i] = tmp;
    }
    delete [] tmpVect;
  }
};
}
#endif