Rank.h

Go to the documentation of this file.

// This file is part of the Peano project. For conditions of distribution and
// use, please see the copyright notice at www.peano-framework.org
#pragma once
 
 
#include "tarch/logging/Log.h"
 
#include <ctime>
#include <functional>
 
 
#include "mpi.h"
 
 
 
namespace tarch {
  namespace mpi {
    class Rank;
  }
}
 
class tarch::mpi::Rank {
  public:
    static const int DEADLOCK_EXIT_CODE = -2;
 
  private:
    static tarch::logging::Log _log;
 
    static Rank  _singleton;
 
    bool _initIsCalled;
 
    int _rank;
 
    int _numberOfProcessors;
 
    int _providedThreadLevelSupport;
 
    #ifdef Parallel
    MPI_Comm _communicator;
    #endif
 
    std::chrono::seconds _timeOutWarning;
 
    std::chrono::seconds _deadlockTimeOut;
 
    std::chrono::system_clock::time_point  _globalTimeOutWarning;
    std::chrono::system_clock::time_point  _globalTimeOutDeadlock;
 
    bool    _areTimeoutsEnabled;
 
    static int     _maxTags;
 
    static int     _tagCounter;
 
    Rank();
 
    Rank( const Rank& node ) = delete;
 
    void receiveDanglingMessagesFromReceiveBuffers();
 
  public:
    static bool validateMaxTagIsSupported();
 
    static int reserveFreeTag(const std::string& fullQualifiedMessageName, int numberOfTags = 1);
    static void releaseTag(int tag);
 
    void barrier(std::function<void()> waitor = []() -> void {} );
 
    #ifdef Parallel
    void allReduce(
      const void *sendbuf, void *recvbuf, int count,
      MPI_Datatype datatype,
      MPI_Op op,
      std::function<void()> waitor = []() -> void {}
    );
 
 
    void reduce(
      const void *sendbuf, void *recvbuf, int count,
      MPI_Datatype datatype,
      MPI_Op op, int root,
      std::function<void()> waitor = []() -> void {}
    );
    #endif
 
    bool isMessageInQueue(int tag) const;
 
    void logStatus() const;
 
    static Rank& getInstance();
 
    virtual ~Rank();
 
    bool init(int* argc, char*** argv);
 
    void shutdown();
 
    int getRank() const;
 
    static int getGlobalMasterRank();
 
    #ifdef Parallel
    MPI_Comm getCommunicator() const;
    #endif
 
    int getNumberOfRanks() const;
 
    bool isGlobalMaster() const;
 
    void triggerDeadlockTimeOut(
      const std::string&  className,
      const std::string&  methodName,
      int                 communicationPartnerRank,
      int                 tag,
      int                 numberOfExpectedMessages = 1,
      const std::string&  comment = ""
    );
 
    void writeTimeOutWarning(
      const std::string&  className,
      const std::string&  methodName,
      int                 communicationPartnerRank,
      int                 tag,
      int                 numberOfExpectedMessages = 1
    );
 
    bool exceededTimeOutWarningThreshold() const;
 
    bool exceededDeadlockThreshold() const;
 
    void plotMessageQueues();
 
    void ensureThatMessageQueuesAreEmpty( int fromRank, int tag );
 
    void setDeadlockWarningTimeStamp();
 
    void setDeadlockTimeOutTimeStamp();
 
    bool isInitialised() const;
 
    void setTimeOutWarning( int valueInSeconds );
 
    void setDeadlockTimeOut( int valueInSeconds );
 
    #ifdef Parallel
    void setCommunicator( MPI_Comm communicator, bool recomputeRankAndWorld=true );
    #endif
 
    void suspendTimeouts( bool timeoutsDisabled );
 
    static void abort(int errorCode);
 
    int getProvidedThreadLevelSupport() const;
 
};