ParBranchAndBound.h

Go to the documentation of this file.

// 
//     Minotaur -- It's only 1/2 bull
// 
//     (C)opyright 2008 - 2025 The Minotaur Team.
// 
 
#ifndef MINOTAURPARBRANCHANDBOUND_H
#define MINOTAURPARBRANCHANDBOUND_H
 
#include "Types.h"
#include <sys/time.h>
 
namespace Minotaur {
 
  struct  ParBabOptions;
  struct  ParBabStats;
  class   Engine;
  class   NodeProcessor;
  class   NodeRelaxer;
  class   ParNodeIncRelaxer;
  class   ParPCBProcessor;
  class   ParTreeManager;
  class   Problem;
  class   Solution;
  class   SolutionPool;
  class   WarmStart;
  class   Timer;
  typedef Engine* EnginePtr;
  typedef ParBabOptions* ParBabOptionsPtr;
  typedef NodeProcessor* NodeProcessorPtr;
  typedef NodeRelaxer* NodeRelaxerPtr;
  typedef ParNodeIncRelaxer* ParNodeIncRelaxerPtr;
  typedef ParPCBProcessor* ParPCBProcessorPtr;
  typedef Solution* SolutionPtr;
  typedef SolutionPool* SolutionPoolPtr;
  typedef ParTreeManager* ParTreeManagerPtr;
  typedef WarmStart* WarmStartPtr;
 
  class ParBranchAndBound {
 
  public:
    ParBranchAndBound();
 
    ParBranchAndBound(EnvPtr env, ProblemPtr p);
 
    virtual ~ParBranchAndBound();
 
    void printsomething();
    void addPreRootHeur(HeurPtr h);
 
    double getPerGap();
 
    double getLb();
 
    NodeProcessorPtr getNodeProcessor();
 
    NodeRelaxerPtr getNodeRelaxer(); 
 
    /*
     * \brief Return solution from the last solve. If no solution was found, return
     * NULL.
     */
    SolutionPtr getSolution();
 
    SolveStatus getStatus();
 
    ParTreeManagerPtr getTreeManager(); 
 
    double getUb();
 
    std::vector<std::vector<double> > mapSerialOutput (
      std::vector<std::vector<double> >serVec,
      std::vector<std::vector<double> >parVec);
 
    UInt numProcNodes();
 
    void setLogLevel(LogLevel level);
 
    void setNodeProcessor(NodeProcessorPtr p);
 
    void setNodeRelaxer(NodeRelaxerPtr nr);
 
    void shouldCreateRoot(bool b);
 
    void solve();
 
    int strToInt(std::string str);
 
    void parsolve(ParNodeIncRelaxerPtr parNodeRelaxer[],
                  ParPCBProcessorPtr parPCBProcessor[],
                  UInt nThreads);
 
    void parsolveOppor(ParNodeIncRelaxerPtr parNodeRelaxer[],
                  ParPCBProcessorPtr parPCBProcessor[],
                  UInt nThreads);
 
    void parsolveSync(ParNodeIncRelaxerPtr parNodeRelaxer[],
                  ParPCBProcessorPtr parPCBProcessor[],
                  UInt nThreads);
 
    void print2dvec(std::vector<std::vector<int> > output);
 
    void print2dvec(std::vector<std::vector<double> > output);
 
    std::vector<std::vector<double> > readSerialOutput(const char* inputFile);
 
    double totalTime();
 
    void writeStats(std::ostream & out);
 
    void writeParStats(std::ostream & out,
                       ParPCBProcessorPtr parPCBProcessor[]);
 
    void writeStats();
 
    double getWallTime() {
      struct timeval time;
      if (gettimeofday(&time,NULL)) {
        // Handle error
        return 0;
      }
      return (double)time.tv_sec + (double)time.tv_usec * .000001;
    }
 
  private:
    EnvPtr env_;
 
    LoggerPtr logger_;
 
    static const std::string me_;
 
    NodeProcessorPtr nodePrcssr_;
 
    NodeRelaxerPtr nodeRlxr_;
 
    ParBabOptionsPtr options_;
 
    HeurVector preHeurs_;
 
    ProblemPtr problem_;
 
    SolutionPoolPtr solPool_;
 
    ParBabStats *stats_;
 
    SolveStatus status_;
 
    Timer *timer_;
   
    ParTreeManagerPtr tm_;
 
    NodePtr processRoot_(bool *should_prune, bool *should_dive);
 
    void processRoot_(bool *should_prune, bool *should_dive,
                         ParNodeIncRelaxerPtr parNodeRlxr,
                         ParPCBProcessorPtr nodePrcssr, WarmStartPtr ws,
                         NodePtr &node);
 
 
    bool shouldPrune_(NodePtr node);
 
    bool shouldStop_();
    
    bool shouldStopPar_(double wallStartTime, double treeLb);
 
    void showStatus_(bool current_uncounted);
 
    void showParStatus_(UInt current_uncounted, double treeLb,
                        double wallStartTime, UInt threadId);
  };
 
  struct ParBabStats 
  {
    ParBabStats();
 
    UInt nodesProc;
 
    double timeUsed;
 
    double updateTime;
  };
 
 
  struct ParBabOptions
  {
    ParBabOptions();
 
    ParBabOptions(EnvPtr env);
    
    bool createRoot;
 
    double logInterval;
 
    UInt nodeLimit;
 
     double perGapLimit;
 
    UInt solLimit;
 
    double timeLimit;
  };
 
  typedef ParBranchAndBound* ParBranchAndBoundPtr;
}
#endif