parmaster.h

Go to the documentation of this file.

#ifndef ABA_PARMASTER_H
#define ABA_PARMASTER_H

#include "abacus/abacusroot.h"
#include "abacus/array.h"
#include "abacus/sub.h"
#include "abacus/idmap.h"
#include "abacus/message.h"
#include "abacus/broadcast.h"
#include "abacus/dualbound.h"

class ABA_MASTER;
class ABA_NOTIFYSERVER;
class ABA_SUBSERVER;
class ABA_BALANCER;
template <class Type> class ABA_IDMAP;

  class  ABA_PARMASTER :  public ABA_ABACUSROOT  {
    public:

      ABA_PARMASTER(ABA_MASTER *master);

      ~ABA_PARMASTER();

      void initializeParameters();

      void setDefaultParameters();

      void printParameters();

      void outputStatistics();
      int hostId() const;
      int hostCount() const;
      bool isHostZero() const;
      const ABA_STRING& hostname(int i) const;
      const ABA_STRING& hostname() const;

      int registerPool(void *pool);

      void unregisterPool(int index);

      void *getPool(int index);
      ABA_IDMAP<ABA_SUB> *subIdentificationMap() const;

      void connectService(int port, ABA_MESSAGE& msg, int destId);
      ACE_SOCK_Stream& notifyStream(int i);

      void newHostDualBound(double x);

      void newHostDualBound(ABA_MESSAGE& msg);

      void newPrimalBound(double x);

      void newPrimalBound(ABA_MESSAGE& msg);

      void newOpenSubCount(int n, double best);

      void newOpenSubCount(ABA_MESSAGE& msg);

      bool balance();

      void terminationCheck();

      void terminationCheck(ABA_MESSAGE& msg);

      void startTerminationCheck();

      void incWorkCount();

      void decWorkCount();

      void terminate();

      int newId(int fatherId);
      void incSubSentCount();
      void incSubReceivedCount();
      void startIdleTime();
      void stopIdleTime();
      void updateIdleTimers(bool first);

      void printId(int id);

    private:
      ABA_MASTER            *master_;
      int                    hostId_;
      int                    hostCount_;
      ABA_STRING             myHostname_;
      ABA_ARRAY<ABA_STRING*> hostname_;
      int                    connectTimeout_;
      ABA_ARRAY<void*>       registeredPools_;
      int                    lastRegisteredPool_;
      ABA_DUALBOUND          hostDualBounds_;
      ACE_Thread_Mutex       newHostDualBoundMutex_;
      ACE_Thread_Mutex       newPrimalBoundMutex_;
      int                    notifyPort_;
      ACE_SOCK_Stream       *notifyStreams_;
      ABA_NOTIFYSERVER      *notify_;
      int                    subserverPort_;
      ABA_SUBSERVER         *subserver_;
      int                    balancerPort_;
      double                 bestFirstTolerance_;
      ABA_BALANCER          *balancer_;
      ABA_ARRAY<int>         openSubCount_;
      ABA_DUALBOUND          openSubBest_;
      ACE_Thread_Mutex       newOpenSubCountMutex_;
      ACE_Thread_Mutex       terminationCheckMutex_;
      volatile bool          terminationCheckAgain_;
      ACE_Thread_Mutex       terminationMutex_;
      volatile bool          terminationOk_;
      volatile bool          hasTerminated_;
      int                    workCount_;
      ACE_Thread_Mutex       idCounterMutex_;
      int                    idCounter_;
      int                    subSentCount_;
      int                    subReceivedCount_;
      ABA_COWTIMER           idleCowTimeFirst_;
      ABA_COWTIMER           idleCowTimeMiddle_;
      ABA_COWTIMER           idleCowTimeLast_;
  };

inline int ABA_PARMASTER::hostId() const {
  return hostId_;
}

inline int ABA_PARMASTER::hostCount() const {
  return hostCount_;
}

inline bool ABA_PARMASTER::isHostZero() const {
  return hostId_==0;
}

inline const ABA_STRING& ABA_PARMASTER::hostname(int i) const {
  return *(hostname_[i]);
}

inline const ABA_STRING& ABA_PARMASTER::hostname() const {
  return *(hostname_[hostId_]);
}

inline ACE_SOCK_Stream& ABA_PARMASTER::notifyStream(int i) {
  return notifyStreams_[i];
}

inline void ABA_PARMASTER::incSubSentCount() {
  subSentCount_++;
}

inline void ABA_PARMASTER::incSubReceivedCount() {
  subReceivedCount_++;
}
  
inline void ABA_PARMASTER::startIdleTime() {
  idleCowTimeLast_.start();
}

inline void ABA_PARMASTER::stopIdleTime() {
  idleCowTimeLast_.stop();
}

inline void ABA_PARMASTER::updateIdleTimers(bool first) {
  if (first)
    idleCowTimeFirst_.addCentiSeconds(idleCowTimeLast_.centiSeconds());
  else
    idleCowTimeMiddle_.addCentiSeconds(idleCowTimeLast_.centiSeconds());
  idleCowTimeLast_.reset();
}

#endif  // ABA_PARMASTER_H

---