Zoltan2_MachineRepresentation.hpp

Go to the documentation of this file.

#ifndef _ZOLTAN2_MACHINEREPRESENTATION_HPP_
#define _ZOLTAN2_MACHINEREPRESENTATION_HPP_
 
#include <Teuchos_Comm.hpp>
#include <Teuchos_StandardParameterEntryValidators.hpp>
#include <Teuchos_ParameterList.hpp>
 
#include <Zoltan2_MachineForTesting.hpp>
//#include <Zoltan2_MachineTorusLDMS.hpp>
#include <Zoltan2_MachineTorusTopoMgr.hpp>
#include <Zoltan2_MachineTorusTopoMgrForTesting.hpp>
#include <Zoltan2_MachineTorusRCA.hpp>
#include <Zoltan2_MachineTorusRCAForTesting.hpp>
#include <Zoltan2_MachineDragonflyRCA.hpp>
#include <Zoltan2_MachineDragonflyRCAForTesting.hpp>
#include <Zoltan2_Environment.hpp>
 
//#define HAVE_ZOLTAN2_BGQTEST
namespace Zoltan2{
 
template <typename pcoord_t, typename part_t>
class MachineRepresentation{
 
public:
    typedef pcoord_t machine_pcoord_t;
    typedef part_t machine_part_t;
/*
#if defined(HAVE_ZOLTAN2_LDMS)
  #if defined(ZOLTAN2_MACHINE_TORUS)
    // TODO: Full LDMS Implementation 
    typedef MachineTorusLDMS<pcoord_t, part_t> machine_t;
  #else 
    typedef MachineForTesting<pcoord_t, part_t> machine_t;
  #endif
*/
#if defined(HAVE_ZOLTAN2_RCALIB) 
  #if defined(ZOLTAN2_MACHINE_TORUS)
    typedef MachineTorusRCA<pcoord_t, part_t> machine_t;
  #elif defined(ZOLTAN2_MACHINE_DRAGONFLY)  
    typedef MachineDragonflyRCA<pcoord_t, part_t> machine_t;
  #else
    typedef MachineForTesting<pcoord_t, part_t> machine_t;
  #endif
 
#elif defined(HAVE_ZOLTAN2_TOPOMANAGER)
  #if defined(ZOLTAN2_MACHINE_TORUS)
    typedef MachineTorusTopoMgr<pcoord_t, part_t> machine_t;
  #else 
    typedef MachineForTesting<pcoord_t, part_t> machine_t;
  #endif
 
#elif defined(HAVE_ZOLTAN2_BGQTEST)
  #if defined(ZOLTAN2_MACHINE_TORUS)
    typedef MachineTorusBGQTest<pcoord_t, part_t> machine_t;
  #else 
    typedef MachineForTesting<pcoord_t, part_t> machine_t;
  #endif
    
#else
  #if defined(ZOLTAN2_MACHINE_TORUS)
    typedef MachineTorusRCAForTesting<pcoord_t, part_t> machine_t;
  #elif defined(ZOLTAN2_MACHINE_DRAGONFLY)
    typedef MachineDragonflyRCAForTesting<pcoord_t, part_t> machine_t;
  #else 
    typedef MachineForTesting<pcoord_t, part_t> machine_t;
//    typedef MachineTorusRCAForTesting<pcoord_t, part_t> machine_t;
//    typedef MachineDragonflyRCAForTesting<pcoord_t, part_t> machine_t;
  #endif
#endif
 
    MachineRepresentation(const Teuchos::Comm<int> &comm) :
      machine(new machine_t(comm)) {
    }
 
    MachineRepresentation(const Teuchos::Comm<int> &comm, 
                          const Teuchos::ParameterList &pl) :
      machine(new machine_t(comm, pl)) { 
    }
 
    ~MachineRepresentation() { delete machine; }
 
    // Interface functions follow.
    // They are just wrappers around the specific machine's functions.
 
    inline bool hasMachineCoordinates() const { 
      return machine->hasMachineCoordinates();
    }
 
    inline int getMachineDim() const { return machine->getMachineDim(); }
 
    inline bool getMachineExtent(int *nxyz) const { 
      return machine->getMachineExtent(nxyz);
    }
 
    bool getMachineExtentWrapArounds(bool *wrap_around) const {
      return machine->getMachineExtentWrapArounds(wrap_around);
    }
 
    inline bool getMyMachineCoordinate(pcoord_t *xyz) const { 
      return machine->getMyMachineCoordinate(xyz);
    }
 
    inline bool getMachineCoordinate(const int rank,
                                     pcoord_t *xyz) const {
      return machine->getMachineCoordinate(rank, xyz);
    }
 
    inline bool getMachineCoordinate(const char *nodename,
                                     pcoord_t *xyz) const {
      return machine->getMachineCoordinate(nodename, xyz);
    }
 
    inline bool getAllMachineCoordinatesView(pcoord_t **&allCoords) const { 
      return machine->getAllMachineCoordinatesView(allCoords);
    }
 
    inline int getNumRanks() const { return machine->getNumRanks(); }
 
    inline bool getHopCount(int rank1, int rank2, pcoord_t &hops) const {
      return machine->getHopCount(rank1, rank2, hops);
    }
 
    inline part_t getNumUniqueGroups() const {
      return machine->getNumUniqueGroups();
    }
 
    inline bool getGroupCount(part_t *grp_count) const {
      return machine->getGroupCount(grp_count);
    }
 
    static void getValidParameters(Teuchos::ParameterList &pl)
    {
      //TODO: This should be positive integer validator.
      pl.set("Machine_Optimization_Level", 10,
          "Machine Coordinate Transformation Method",
          Environment::getAnyIntValidator());
 
      // validator for file does not have to exist
      RCP<Teuchos::FileNameValidator> file_not_required_validator =
        Teuchos::rcp( new Teuchos::FileNameValidator(false) );
 
      // bool parameter
      pl.set("Input_RCA_Machine_Coords", "", 
             "Input File for input machine coordinates",
             file_not_required_validator);
    }
 
    // KDD TODO: Add Graph interface and methods supporting full LDMS 
    // interface.
 
private:
    machine_t *machine;
};
 
} // namespace Zoltan2
 
#endif