ParallelFixedSamplesMIMCMC.h

Go to the documentation of this file.

#ifndef PARALLELFIXEDSAMPLESMIMCMC_H_
#define PARALLELFIXEDSAMPLESMIMCMC_H_
 
#include "MUQ/config.h"
 
#if MUQ_HAS_MPI
 
#if !MUQ_HAS_PARCER
#error
#endif
 
#include "spdlog/spdlog.h"
#include <boost/property_tree/ptree.hpp>
 
#include "MUQ/SamplingAlgorithms/ParallelMIMCMCWorker.h"
#include "MUQ/SamplingAlgorithms/ParallelizableMIComponentFactory.h"
#include "MUQ/SamplingAlgorithms/SamplingAlgorithm.h"
 
namespace muq {
  namespace SamplingAlgorithms {
 
    class StaticLoadBalancer {
    public:
      struct WorkerAssignment {
        int numGroups;
        int numWorkersPerGroup;
      };
 
      virtual void setup(std::shared_ptr<ParallelizableMIComponentFactory> componentFactory, uint availableRanks) = 0;
 
      virtual int numCollectors(std::shared_ptr<MultiIndex> modelIndex) = 0;
 
      virtual WorkerAssignment numWorkers(std::shared_ptr<MultiIndex> modelIndex) = 0;
    };
 
    class RoundRobinStaticLoadBalancer : public StaticLoadBalancer {
    public:
      void setup(std::shared_ptr<ParallelizableMIComponentFactory> componentFactory, uint availableRanks) override;
 
      int numCollectors(std::shared_ptr<MultiIndex> modelIndex) override;
 
      WorkerAssignment numWorkers(std::shared_ptr<MultiIndex> modelIndex) override;
 
    private:
      uint ranks_remaining;
      uint models_remaining;
 
    };
 
    class StaticLoadBalancingMIMCMC : public SamplingAlgorithm {
    public:
      StaticLoadBalancingMIMCMC (pt::ptree pt,
                                 std::shared_ptr<ParallelizableMIComponentFactory> componentFactory,
                                 std::shared_ptr<StaticLoadBalancer> loadBalancing = std::make_shared<RoundRobinStaticLoadBalancer>(),
                                 std::shared_ptr<parcer::Communicator> comm = std::make_shared<parcer::Communicator>(MPI_COMM_WORLD),
                                 std::shared_ptr<muq::Utilities::OTF2TracerBase> tracer = std::make_shared<OTF2TracerDummy>());
 
      Eigen::VectorXd MeanQOI();
 
      virtual std::shared_ptr<SampleCollection> GetSamples() const;
 
      virtual std::shared_ptr<SampleCollection> GetQOIs() const;
 
      void Finalize();
 
      void RequestSamples(std::shared_ptr<MultiIndex> index, int numSamples);
 
      void RequestSamplesAll(int numSamples);
 
      void RunSamples();
 
      void WriteToFile(std::string filename);
 
 
    protected:
      virtual std::shared_ptr<SampleCollection> RunImpl(std::vector<Eigen::VectorXd> const& x0);
 
    private:
 
      std::string multiindexToConfigString (std::shared_ptr<MultiIndex> index);
 
      const int rootRank = 0;
      const int phonebookRank = 1;
      pt::ptree pt;
      std::shared_ptr<parcer::Communicator> comm;
      std::shared_ptr<ParallelizableMIComponentFactory> componentFactory;
      std::shared_ptr<PhonebookClient> phonebookClient;
      std::vector<CollectorClient> collectorClients;
      WorkerClient workerClient;
    };
  }
}
 
#endif // #if MUQ_HAS_MPI
#endif // #ifndef PARALLELFIXEDSAMPLESMIMCMC_H_