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                                        *
 *          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-2013, Lehigh University, Yan Xu, and Ted Ralphs.       *
 *===========================================================================*/

#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 {

 private:

    AlpsKnowledgeBroker(const AlpsKnowledgeBroker&);
    AlpsKnowledgeBroker& operator=(const 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();

    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;
    }

    const AlpsKnowledge* decoderObject(int name) {
        return decodeMap_[name];
    }

    //------------------------------------------------------

    virtual void initializeSearch(int argc, 
                                  char* argv[], 
                                  AlpsModel& model) = 0;

    virtual void rootSearch(AlpsTreeNode* root) = 0;  

    virtual void search(AlpsModel *model) {   
        AlpsTreeNode* root = model->createRoot();
        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) {
            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; }
};
#endif