/home/coin/SVN-release/Alps-1.0.3/Alps/src/AlpsKnowledgeBroker.h

Go to the documentation of this file.
00001 /*===========================================================================*
00002  * This file is part of the Abstract Library for Parallel Search (ALPS).     *
00003  *                                                                           *
00004  * ALPS is distributed under the Common Public License as part of the        *
00005  * COIN-OR repository (http://www.coin-or.org).                              *
00006  *                                                                           *
00007  * Authors:                                                                  *
00008  *                                                                           *
00009  *          Yan Xu, Lehigh University                                        *
00010  *          Ted Ralphs, Lehigh University                                    *
00011  *                                                                           *
00012  * Conceptual Design:                                                        *
00013  *                                                                           *
00014  *          Yan Xu, Lehigh University                                        *
00015  *          Ted Ralphs, Lehigh University                                    *
00016  *          Laszlo Ladanyi, IBM T.J. Watson Research Center                  *
00017  *          Matthew Saltzman, Clemson University                             *
00018  *                                                                           * 
00019  *                                                                           *
00020  * Copyright (C) 2001-2008, Lehigh University, Yan Xu, and Ted Ralphs.       *
00021  *===========================================================================*/
00022 
00023 #ifndef AlpsKnowledgeBroker_h_
00024 #define AlpsKnowledgeBroker_h_
00025 
00026 #include <cmath>
00027 #include <iosfwd>
00028 #include <map>
00029 #include <string>
00030 
00031 #include "CoinMessageHandler.hpp"
00032 
00033 #include "AlpsSearchStrategy.h"
00034 #include "AlpsEnumProcessT.h"
00035 #include "AlpsKnowledge.h"
00036 #include "AlpsKnowledgePool.h"
00037 #include "AlpsMessage.h"
00038 #include "AlpsParams.h"
00039 #include "AlpsSolutionPool.h"
00040 #include "AlpsSubTree.h"
00041 #include "AlpsSubTreePool.h"
00042 #include "AlpsModel.h"
00043 #include "AlpsTime.h"
00044 
00045 //#############################################################################
00046 
00048 class AlpsKnowledgeBroker {
00049 
00050  private:
00051 
00052     AlpsKnowledgeBroker(const AlpsKnowledgeBroker&);
00053     AlpsKnowledgeBroker& operator=(const AlpsKnowledgeBroker&);
00054 
00056     std::map<int, AlpsKnowledge*> decodeMap_;
00057     
00058  protected:
00059 
00061     std::string instanceName_;
00062 
00064     AlpsModel *model_;
00065 
00067     AlpsPhase phase_;
00068 
00075     AlpsSubTreePool* subTreePool_;
00076 
00078     AlpsSolutionPool* solPool_;
00079 
00081     std::map<AlpsKnowledgeType, AlpsKnowledgePool*>* pools_;
00083 
00089     AlpsSubTree* workingSubTree_;
00090     
00092     bool needWorkingSubTree_;
00093 
00095     AlpsNodeIndex_t nextIndex_;
00096 
00098     AlpsNodeIndex_t maxIndex_;
00100 
00105     /***/
00107     AlpsTimer timer_;
00108 
00110     AlpsTimer subTreeTimer_;
00111 
00113     AlpsTimer tempTimer_;
00114 
00116     int nodeProcessedNum_;
00117 
00120     int systemNodeProcessed_;
00121     
00123     int nodeLeftNum_;
00124     
00126     int treeDepth_;
00127 
00129     int bestSolDepth_;
00130 
00132     int bestSolNode_;
00133 
00135     double peakMemory_;
00136 
00138     AlpsExitStatus exitStatus_;
00140     
00146     AlpsSearchStrategy<AlpsSubTree*>* treeSelection_;
00147 
00149     AlpsSearchStrategy<AlpsTreeNode*>* nodeSelection_;
00150 
00152     AlpsSearchStrategy<AlpsTreeNode*>* rampUpNodeSelection_;
00154     
00160     CoinMessageHandler * handler_;
00161 
00163     CoinMessages messages_;
00164 
00167     int msgLevel_;
00168 
00171     int hubMsgLevel_;
00172 
00175     int workerMsgLevel_;
00176     
00179     int logFileLevel_;
00180 
00182     std::string logfile_;
00184 
00186     int nodeMemSize_;
00187 
00189     double nodeProcessingTime_;
00190 
00192     int largeSize_;
00193 
00195     bool userBalancePeriod_;
00196     
00198     int numNodeLog_;
00199     
00200  public:
00201 
00203     AlpsKnowledgeBroker();
00204 
00206     virtual ~AlpsKnowledgeBroker();
00207 
00208     //-------------------------------------------------------------------------
00221     void registerClass(int name, AlpsKnowledge* userKnowledge) {
00222         // Check if alread have one.
00223         std::map<int, AlpsKnowledge*>::iterator pos, pos1;
00224         pos = decodeMap_.find(name);
00225         pos1 = decodeMap_.end();
00226         
00227         if (pos != pos1) {
00228             AlpsKnowledge* kl = pos->second;
00229             decodeMap_.erase(pos);
00230             delete kl;
00231         }
00232         
00233         decodeMap_[name] = userKnowledge;
00234     }
00235 
00244     const AlpsKnowledge* decoderObject(int name) {
00245         return decodeMap_[name];
00246     }
00248 
00249     //------------------------------------------------------
00250 
00256     virtual void initializeSearch(int argc, 
00257                                   char* argv[], 
00258                                   AlpsModel& model) = 0;
00259 
00261     virtual void rootSearch(AlpsTreeNode* root) = 0;  
00262 
00264     virtual void search(AlpsModel *model) {   
00265         AlpsTreeNode* root = model->createRoot();
00266         rootSearch(root);
00267     }
00269 
00270     //------------------------------------------------------
00271 
00276     AlpsPhase getPhase() { return phase_; }
00277     void setPhase(AlpsPhase ph) { phase_ = ph; }
00279 
00281     AlpsModel *getModel() { return model_; }
00282     void setModel(AlpsModel *m) { model_ = m; }
00284 
00286     int getTreeDepth() { return treeDepth_; }
00287 
00289     int getBestSolDepth() { return bestSolDepth_; }
00290 
00292     void setBestSolDepth(int depth) { bestSolDepth_ = depth; }
00293 
00295     void setPeakMemory(double size) { peakMemory_ = size; }
00296 
00298     double getPeakMemory() { return peakMemory_; }
00299     
00305     void setupKnowledgePools();
00306     
00308     inline void addKnowledgePool(AlpsKnowledgeType kt, AlpsKnowledgePool* kp) {
00309         if(kt == AlpsKnowledgeTypeSolution || kt == AlpsKnowledgeTypeSubTree) {
00310             // AlpsKnowledgePool* akp = static_cast<AlpsKnowledgePool*>(kp);
00311             pools_->insert
00312                 (std::pair<AlpsKnowledgeType, AlpsKnowledgePool*>(kt, kp));
00313         }
00314         else {
00315             throw CoinError("Broker doesn't manage this type of knowledge", 
00316                             "addKnowledgePool()", "AlpsKnowledgeBroker"); 
00317         }
00318     }
00319   
00321     inline  AlpsKnowledgePool* getKnowledgePool(AlpsKnowledgeType kt) const { 
00322         if(kt == AlpsKnowledgeTypeSolution || kt == AlpsKnowledgeTypeSubTree) {
00323             return (*pools_)[kt];
00324         }
00325         else {
00326             throw CoinError("Broker doesn't manage this type of knowledge", 
00327                             "getKnowledgePool()", "AlpsKnowledgeBroker"); 
00328         }
00329     }
00330 
00332     virtual int getNumKnowledges(AlpsKnowledgeType kt) const;
00333     
00336     virtual int getMaxNumKnowledges(AlpsKnowledgeType kt) const {
00337         if(kt == AlpsKnowledgeTypeSolution || kt == AlpsKnowledgeTypeSubTree) {
00338             return getKnowledgePool(kt)->getMaxNumKnowledges();
00339         }
00340         else {
00341             throw CoinError("Broker doesn't manage this type of knowledge", 
00342                             "getMaxNumKnowledges()", "AlpsKnowledgeBroker"); 
00343         }
00344     }
00345 
00348     virtual void setMaxNumKnowledges(AlpsKnowledgeType kt, int num) {
00349         if(kt == AlpsKnowledgeTypeSolution || kt == AlpsKnowledgeTypeSubTree) {
00350             getKnowledgePool(kt)->setMaxNumKnowledges(num);
00351         }
00352         else {
00353             throw CoinError("Broker doesn't manage this type of knowledge", 
00354                             "setMaxNumKnowledges()", "AlpsKnowledgeBroker"); 
00355         }
00356     }
00357 
00360     virtual bool hasKnowledge(AlpsKnowledgeType kt) const {
00361         if(kt == AlpsKnowledgeTypeSolution || kt == AlpsKnowledgeTypeSubTree)
00362             return getKnowledgePool(kt)->hasKnowledge();
00363         else
00364             throw CoinError("Broker doesn't manage this type of knowledge", 
00365                             "hasKnowledge()", "AlpsKnowledgeBroker"); 
00366     }
00367 
00369     virtual std::pair<AlpsKnowledge*, double> 
00370         getKnowledge(AlpsKnowledgeType kt) const {
00371         if(kt == AlpsKnowledgeTypeSolution || kt == AlpsKnowledgeTypeSubTree) {
00372             return getKnowledgePool(kt)->getKnowledge();
00373         }
00374         else {
00375             throw CoinError("Broker doesn't manage this type of knowledge", 
00376                             "getKnowledge()", "AlpsKnowledgeBroker"); 
00377         }
00378     }
00379 
00381     virtual void popKnowledge(AlpsKnowledgeType kt) {
00382         if(kt == AlpsKnowledgeTypeSolution || kt == AlpsKnowledgeTypeSubTree) {
00383             getKnowledgePool(kt)->popKnowledge();
00384         }
00385         else {
00386             throw CoinError("Broker doesn't manage this type of knowledge", 
00387                             "popKnowledge()", "AlpsKnowledgeBroker"); 
00388         }
00389     } 
00390 
00392     virtual std::pair<AlpsKnowledge*, double> 
00393         getBestKnowledge(AlpsKnowledgeType kt) const;
00394 
00396     virtual void getAllKnowledges (AlpsKnowledgeType kt, 
00397                                    std::vector<std::pair<AlpsKnowledge*, 
00398                                    double> >& kls)  const { 
00399         if(kt == AlpsKnowledgeTypeSolution || kt == AlpsKnowledgeTypeSubTree) {
00400             getKnowledgePool(kt)->getAllKnowledges(kls);
00401         }
00402         else {
00403             throw CoinError("Broker doesn't manage this type of knowledge", 
00404                             "popKnowledge()", "AlpsKnowledgeBroker"); 
00405         }
00406     }
00407 
00409     virtual void addKnowledge(AlpsKnowledgeType kt, 
00410                               AlpsKnowledge* kl, 
00411                               double value ) { 
00412         if(kt == AlpsKnowledgeTypeSolution || kt == AlpsKnowledgeTypeSubTree) {
00413             getKnowledgePool(kt)->addKnowledge(kl, value);
00414         }
00415         else {
00416             throw CoinError("Broker doesn't manage this type of knowledge", 
00417                             "popKnowledge()", "AlpsKnowledgeBroker"); 
00418         }
00419     }
00421 
00426     int getNumNodesProcessed() const {
00427         return nodeProcessedNum_;
00428     }
00429 
00431     int getNumNodesProcessedSystem() const {
00432         return systemNodeProcessed_;
00433     }
00434 
00436     virtual int updateNumNodesLeft();
00437     
00439     virtual AlpsTreeNode* getBestNode() const;
00440 
00442     AlpsExitStatus getSolStatus() const {
00443         return exitStatus_;
00444     }
00445 
00447     void setExitStatus(AlpsExitStatus status) {
00448         exitStatus_ = status;
00449     }
00450 
00452     AlpsTimer & timer() {
00453         return timer_;
00454     }
00455 
00457     AlpsTimer & subTreeTimer() {
00458         return subTreeTimer_;
00459     }
00460 
00462     AlpsTimer & tempTimer() {
00463         return tempTimer_;
00464     }
00465 
00467     virtual void searchLog() = 0;
00469 
00474     int getNodeMemSize() { return nodeMemSize_; }
00475     void setNodeMemSize(int ms) { nodeMemSize_ = ms; }
00477 
00482     double getNodeProcessingTime() { return nodeProcessingTime_; }
00483     void setNodeProcessingTime(double npTime) { nodeProcessingTime_ = npTime; }
00485 
00486     int getLargeSize() const { return largeSize_; }
00487 
00494     virtual double getIncumbentValue() const = 0;
00495 
00498     virtual double getBestQuality() const = 0;
00499 
00501     virtual double getBestEstimateQuality() { return ALPS_OBJ_MAX; }
00502 
00503     virtual int getNumNodeLeftSystem(){ return nodeLeftNum_; }
00504 
00507     virtual void printBestSolution(char* outputFile = 0) const = 0;
00509 
00511     virtual int getProcRank() const { return 0; }
00512     
00514     virtual int getMasterRank() const { return 0; }
00515 
00517     virtual AlpsProcessType getProcType() const
00518     { return AlpsProcessTypeSerial; } /* Default is serial */
00519     
00526     AlpsNodeIndex_t nextNodeIndex() { return nextIndex_++; }
00527 
00529     AlpsNodeIndex_t getNextNodeIndex() const { return nextIndex_; }
00530 
00532     void setNextNodeIndex(AlpsNodeIndex_t s) { nextIndex_ = s; } 
00533 
00535     AlpsNodeIndex_t getMaxNodeIndex() const { return maxIndex_; }
00536   
00538     void setMaxNodeIndex(AlpsNodeIndex_t s) { maxIndex_ = s; }
00540 
00545     AlpsSearchStrategy<AlpsSubTree*>* getSubTreeSelection() const { 
00546         return treeSelection_; 
00547     }
00548     void setSubTreeSelection(AlpsSearchStrategy<AlpsSubTree*>* tc) {
00549         if (treeSelection_) delete treeSelection_;
00550         treeSelection_ = tc;
00551         subTreePool_->setComparison(*treeSelection_);
00552     }
00553     AlpsSearchStrategy<AlpsTreeNode*>* getNodeSelection() const {
00554         return nodeSelection_;
00555     }
00556     void setNodeSelection(AlpsSearchStrategy<AlpsTreeNode*>* nc) {
00557         if (nodeSelection_) delete nodeSelection_;
00558         nodeSelection_ = nc;
00559     }
00560     AlpsSearchStrategy<AlpsTreeNode*>* getRampUpNodeSelection() const {
00561         return rampUpNodeSelection_;
00562     }
00563     void setRampUpNodeSelection(AlpsSearchStrategy<AlpsTreeNode*>* nc) {
00564         if (rampUpNodeSelection_) delete rampUpNodeSelection_;
00565         rampUpNodeSelection_ = nc;
00566     }
00568    
00572     void passInMessageHandler(CoinMessageHandler * handler);
00573 
00575     void newLanguage(CoinMessages::Language language);
00576     void setLanguage(CoinMessages::Language language)
00577     { newLanguage(language); }
00578 
00580     CoinMessageHandler * messageHandler() const { return handler_; }
00581 
00583     CoinMessages messages() { return messages_; }
00584 
00586     CoinMessages * messagesPointer() { return &messages_; }
00587 
00589     int getMsgLevel() { return msgLevel_; }
00590 
00592     int getHubMsgLevel() { return hubMsgLevel_; }
00593 
00595     int getMasterMsgLevel() { return workerMsgLevel_; }
00596 
00598     int getlogFileLevel() { return logFileLevel_; }
00599 
00601     int getNumNodeLog() const { return numNodeLog_; }
00602     
00604     void setNumNodeLog(int num) { numNodeLog_ = num; }
00606 };
00607 #endif

Generated on Tue Sep 23 03:08:15 2008 by  doxygen 1.4.7