AlpsKnowledgeBroker.h

Go to the documentation of this file.

/*===========================================================================*
 * This file is part of the Abstract Library for Parallel Search (ALPS).     *
 *                                                                           *
 * ALPS is distributed under the Eclipse Public License as part of the       *
 * COIN-OR repository (http://www.coin-or.org).                              *
 *                                                                           *
 * Authors:                                                                  *
 *                                                                           *
 *          Yan Xu, Lehigh University                                        *
 *          Aykut Bulut, Lehigh University                                   *
 *          Ted Ralphs, Lehigh University                                    *
 *                                                                           *
 * Conceptual Design:                                                        *
 *                                                                           *
 *          Yan Xu, Lehigh University                                        *
 *          Ted Ralphs, Lehigh University                                    *
 *          Laszlo Ladanyi, IBM T.J. Watson Research Center                  *
 *          Matthew Saltzman, Clemson University                             *
 *                                                                           *
 *                                                                           *
 * Copyright (C) 2001-2023, Lehigh University, Yan Xu, Aykut Bulut, and      *
 *                          Ted Ralphs.                                      *
 * All Rights Reserved.                                                      *
 *===========================================================================*/
 
 
#ifndef AlpsKnowledgeBroker_h_
#define AlpsKnowledgeBroker_h_
 
#include <cmath>
#include <iosfwd>
#include <map>
#include <string>
 
#include "CoinMessageHandler.hpp"
 
#include "AlpsSearchStrategy.h"
#include "AlpsEnumProcessT.h"
#include "AlpsKnowledge.h"
#include "AlpsKnowledgePool.h"
#include "AlpsMessage.h"
#include "AlpsParams.h"
#include "AlpsSolutionPool.h"
#include "AlpsSubTree.h"
#include "AlpsSubTreePool.h"
#include "AlpsModel.h"
#include "AlpsTime.h"
 
//#############################################################################
 
class AlpsKnowledgeBroker {
  std::map<int, AlpsKnowledge*> decodeMap_;
 
protected:
 
  std::string instanceName_;
  AlpsModel *model_;
  AlpsPhase phase_;
 
 
 
  AlpsSubTreePool* subTreePool_;
  AlpsSolutionPool* solPool_;
  std::map<AlpsKnowledgeType, AlpsKnowledgePool*>* pools_;
 
 
 
  AlpsSubTree* workingSubTree_;
  bool needWorkingSubTree_;
  AlpsNodeIndex_t nextIndex_;
  AlpsNodeIndex_t maxIndex_;
 
 
 
  AlpsTimer timer_;
  AlpsTimer subTreeTimer_;
  AlpsTimer tempTimer_;
  int solNum_;
  int nodeProcessedNum_;
  int nodeBranchedNum_;
  int nodeDiscardedNum_;
  int nodePartialNum_;
  int systemNodeProcessed_;
  int nodeLeftNum_;
  int treeDepth_;
  int bestSolNode_;
  double peakMemory_;
  AlpsExitStatus exitStatus_;
 
 
 
  AlpsSearchStrategy<AlpsSubTree*>* treeSelection_;
  AlpsSearchStrategy<AlpsTreeNode*>* nodeSelection_;
  AlpsSearchStrategy<AlpsTreeNode*>* rampUpNodeSelection_;
 
 
 
  CoinMessageHandler * handler_;
  CoinMessages messages_;
  int msgLevel_;
  int hubMsgLevel_;
  int workerMsgLevel_;
  int logFileLevel_;
  std::string logfile_;
 
  int nodeMemSize_;
  double nodeProcessingTime_;
  int largeSize_;
  bool userBalancePeriod_;
  int numNodeLog_;
 
public:
 
 
  AlpsKnowledgeBroker();
  AlpsKnowledgeBroker(AlpsModel& model);
  virtual ~AlpsKnowledgeBroker();
 
 
 
  void registerClass(int name, AlpsKnowledge* userKnowledge) {
    // Check if alread have one.
    std::map<int, AlpsKnowledge*>::iterator pos, pos1;
    pos = decodeMap_.find(name);
    pos1 = decodeMap_.end();
 
    if (pos != pos1) {
      AlpsKnowledge* kl = pos->second;
      decodeMap_.erase(pos);
      delete kl;
    }
 
    decodeMap_[name] = userKnowledge;
    userKnowledge->setBroker(this);
  }
  AlpsKnowledge const * decoderObject(int name) const {
    // todo(aykut) convert this to .at() once C++11 standard is available.
    std::map<int,AlpsKnowledge*>::const_iterator it = decodeMap_.find(name);
    if (it == decodeMap_.end()) {
      // this should not happen.
      throw std::exception();
    }
    return it->second;
  }
 
 
 
  virtual void initializeSearch(int argc,
                                char* argv[],
                                AlpsModel& model,
                                bool showBanner = true) = 0;
 
  virtual void rootSearch(AlpsTreeNode* root) = 0;
 
  virtual void search(AlpsModel *model) {
    AlpsTreeNode* root = model->createRoot();
    root->setBroker(this);
    root->modifyDesc()->setBroker(this);
    rootSearch(root);
  }
 
 
  AlpsPhase getPhase() { return phase_; }
  void setPhase(AlpsPhase ph) { phase_ = ph; }
 
  AlpsModel *getModel() { return model_; }
  void setModel(AlpsModel *m) { model_ = m; }
 
  int getTreeDepth() { return treeDepth_; }
  void setPeakMemory(double size) { peakMemory_ = size; }
  double getPeakMemory() { return peakMemory_; }
 
  void setupKnowledgePools();
  inline void addKnowledgePool(AlpsKnowledgeType kt, AlpsKnowledgePool* kp) {
    if(kt == AlpsKnowledgeTypeSolution || kt == AlpsKnowledgeTypeSubTree) {
      // AlpsKnowledgePool* akp = static_cast<AlpsKnowledgePool*>(kp);
      pools_->insert
        (std::pair<AlpsKnowledgeType, AlpsKnowledgePool*>(kt, kp));
    }
    else {
      throw CoinError("Broker doesn't manage this type of knowledge",
                      "addKnowledgePool()", "AlpsKnowledgeBroker");
    }
  }
  inline  AlpsKnowledgePool* getKnowledgePool(AlpsKnowledgeType kt) const {
    if(kt == AlpsKnowledgeTypeSolution || kt == AlpsKnowledgeTypeSubTree) {
      return (*pools_)[kt];
    }
    else {
      throw CoinError("Broker doesn't manage this type of knowledge",
                      "getKnowledgePool()", "AlpsKnowledgeBroker");
    }
  }
  virtual int getNumKnowledges(AlpsKnowledgeType kt) const;
  virtual int getMaxNumKnowledges(AlpsKnowledgeType kt) const {
    if(kt == AlpsKnowledgeTypeSolution || kt == AlpsKnowledgeTypeSubTree) {
      return getKnowledgePool(kt)->getMaxNumKnowledges();
    }
    else {
      throw CoinError("Broker doesn't manage this type of knowledge",
                      "getMaxNumKnowledges()", "AlpsKnowledgeBroker");
    }
  }
  virtual void setMaxNumKnowledges(AlpsKnowledgeType kt, int num) {
    if(kt == AlpsKnowledgeTypeSolution || kt == AlpsKnowledgeTypeSubTree) {
      getKnowledgePool(kt)->setMaxNumKnowledges(num);
    }
    else {
      throw CoinError("Broker doesn't manage this type of knowledge",
                      "setMaxNumKnowledges()", "AlpsKnowledgeBroker");
    }
  }
 
  virtual bool hasKnowledge(AlpsKnowledgeType kt) const {
    if(kt == AlpsKnowledgeTypeSolution || kt == AlpsKnowledgeTypeSubTree)
      return getKnowledgePool(kt)->hasKnowledge();
    else
      throw CoinError("Broker doesn't manage this type of knowledge",
                      "hasKnowledge()", "AlpsKnowledgeBroker");
  }
 
  virtual std::pair<AlpsKnowledge*, double>
  getKnowledge(AlpsKnowledgeType kt) const {
    if(kt == AlpsKnowledgeTypeSolution || kt == AlpsKnowledgeTypeSubTree) {
      return getKnowledgePool(kt)->getKnowledge();
    }
    else {
      throw CoinError("Broker doesn't manage this type of knowledge",
                      "getKnowledge()", "AlpsKnowledgeBroker");
    }
  }
 
  virtual void popKnowledge(AlpsKnowledgeType kt) {
    if(kt == AlpsKnowledgeTypeSolution || kt == AlpsKnowledgeTypeSubTree) {
      getKnowledgePool(kt)->popKnowledge();
    }
    else {
      throw CoinError("Broker doesn't manage this type of knowledge",
                      "popKnowledge()", "AlpsKnowledgeBroker");
    }
  }
 
  virtual std::pair<AlpsKnowledge*, double>
  getBestKnowledge(AlpsKnowledgeType kt) const;
 
  virtual void getAllKnowledges (AlpsKnowledgeType kt,
                                 std::vector<std::pair<AlpsKnowledge*,
                                 double> >& kls)  const {
    if(kt == AlpsKnowledgeTypeSolution || kt == AlpsKnowledgeTypeSubTree) {
      getKnowledgePool(kt)->getAllKnowledges(kls);
    }
    else {
      throw CoinError("Broker doesn't manage this type of knowledge",
                      "popKnowledge()", "AlpsKnowledgeBroker");
    }
  }
 
  virtual void addKnowledge(AlpsKnowledgeType kt,
                            AlpsKnowledge* kl,
                            double value ) {
    if(kt == AlpsKnowledgeTypeSolution || kt == AlpsKnowledgeTypeSubTree) {
      //todo(aykut) is this the right place to do this?
      //kl->setType(kt);
      getKnowledgePool(kt)->addKnowledge(kl, value);
    }
    else {
      throw CoinError("Broker doesn't manage this type of knowledge",
                      "popKnowledge()", "AlpsKnowledgeBroker");
    }
  }
 
  int getNumNodesProcessed() const {
    return nodeProcessedNum_;
  }
  int getNumNodesBranched() const {
    return nodeBranchedNum_;
  }
  int getNumNodesDiscarded() const {
    return nodeDiscardedNum_;
  }
  int getNumNodesPartial() const {
    return nodePartialNum_;
  }
  int getNumNodesProcessedSystem() const {
    return systemNodeProcessed_;
  }
  virtual int updateNumNodesLeft();
  virtual AlpsTreeNode* getBestNode() const;
  AlpsExitStatus getSolStatus() const {
    return exitStatus_;
  }
  void setExitStatus(AlpsExitStatus status) {
    exitStatus_ = status;
  }
  AlpsTimer & timer() {
    return timer_;
  }
  AlpsTimer & subTreeTimer() {
    return subTreeTimer_;
  }
  AlpsTimer & tempTimer() {
    return tempTimer_;
  }
  virtual void searchLog() = 0;
 
 
  int getNodeMemSize() { return nodeMemSize_; }
  void setNodeMemSize(int ms) { nodeMemSize_ = ms; }
 
 
  double getNodeProcessingTime() { return nodeProcessingTime_; }
  void setNodeProcessingTime(double npTime) { nodeProcessingTime_ = npTime; }
 
  int getLargeSize() const { return largeSize_; }
 
 
 
  virtual double getIncumbentValue() const = 0;
 
  virtual double getBestQuality() const = 0;
 
  virtual double getBestEstimateQuality() { return ALPS_OBJ_MAX; }
 
  virtual int getNumNodeLeftSystem(){ return nodeLeftNum_; }
 
  virtual void printBestSolution(char* outputFile = 0) const = 0;
 
  virtual int getProcRank() const { return 0; }
 
  virtual int getMasterRank() const { return 0; }
 
  virtual AlpsProcessType getProcType() const
  { return AlpsProcessTypeSerial; } /* Default is serial */
 
 
 
  AlpsNodeIndex_t nextNodeIndex() { return nextIndex_++; }
  AlpsNodeIndex_t getNextNodeIndex() const { return nextIndex_; }
  void setNextNodeIndex(AlpsNodeIndex_t s) { nextIndex_ = s; }
  AlpsNodeIndex_t getMaxNodeIndex() const { return maxIndex_; }
  void setMaxNodeIndex(AlpsNodeIndex_t s) { maxIndex_ = s; }
 
 
  AlpsSearchStrategy<AlpsSubTree*>* getSubTreeSelection() const {
    return treeSelection_;
  }
  void setSubTreeSelection(AlpsSearchStrategy<AlpsSubTree*>* tc) {
    if (treeSelection_) delete treeSelection_;
    treeSelection_ = tc;
    subTreePool_->setComparison(*treeSelection_);
  }
  AlpsSearchStrategy<AlpsTreeNode*>* getNodeSelection() const {
    return nodeSelection_;
  }
  void setNodeSelection(AlpsSearchStrategy<AlpsTreeNode*>* nc) {
    if (nodeSelection_) delete nodeSelection_;
    nodeSelection_ = nc;
  }
  AlpsSearchStrategy<AlpsTreeNode*>* getRampUpNodeSelection() const {
    return rampUpNodeSelection_;
  }
  void setRampUpNodeSelection(AlpsSearchStrategy<AlpsTreeNode*>* nc) {
    if (rampUpNodeSelection_) delete rampUpNodeSelection_;
    rampUpNodeSelection_ = nc;
  }
 
 
 
  void passInMessageHandler(CoinMessageHandler * handler);
  void newLanguage(CoinMessages::Language language);
  void setLanguage(CoinMessages::Language language)
  { newLanguage(language); }
  CoinMessageHandler * messageHandler() const { return handler_; }
  CoinMessages messages() { return messages_; }
  CoinMessages * messagesPointer() { return &messages_; }
  int getMsgLevel() { return msgLevel_; }
  int getHubMsgLevel() { return hubMsgLevel_; }
  int getMasterMsgLevel() { return workerMsgLevel_; }
  int getlogFileLevel() { return logFileLevel_; }
  int getNumNodeLog() const { return numNodeLog_; }
  void setNumNodeLog(int num) { numNodeLog_ = num; }
 
  //Suresh: added temporarily for warm starting
  AlpsSubTree * getWorkingSubTree() {return workingSubTree_;}
 
private:
  AlpsKnowledgeBroker(const AlpsKnowledgeBroker&);
  AlpsKnowledgeBroker& operator=(const AlpsKnowledgeBroker&);
};
#endif