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