LoadBalanceWriter.h

#ifndef SRC_IO_LOADBALANCEWRITER_H_
#define SRC_IO_LOADBALANCEWRITER_H_
 
#include "plugins/PluginBase.h"
#include "utils/Timer.h"
 
#include <string>
#include <vector>
#include <deque>
 
#define LB_WRITER_DEFAULT_TIMER_NAME "LoadbalanceWriter_default"
 
class LoadbalanceWriter : public PluginBase {
public:
    LoadbalanceWriter();
    ~~LoadbalanceWriter() override = default;
 
    void readXML(XMLfileUnits& xmlconfig) override;
 
    void init(ParticleContainer *particleContainer,
              DomainDecompBase *domainDecomp, Domain *domain) override;
 
    void endStep(
            ParticleContainer *particleContainer,
            DomainDecompBase *domainDecomp, Domain *domain,
            unsigned long simstep
    ) override;
 
    void finish(ParticleContainer *particleContainer, DomainDecompBase *domainDecomp, Domain *domain) override {
        /* nothing to do */
    }
 
    std::string getPluginName() override {
        return std::string("LoadbalanceWriter");
    }
    static PluginBase* createInstance() { return new LoadbalanceWriter(); }
 
private:
    void recordTimes(long unsigned int simstep);
    void resetTimes();
    void writeOutputFileHeader();
    void writeLBEntry(size_t id, std::ofstream &outputfile, int numRanks);
    void flush(DomainDecompBase* domainDecomp);
    void displayWarning(unsigned long simstep, const std::string& timername, double f_LB);
 
    unsigned long _writeFrequency;
    unsigned long _averageLength{10};
    std::string _outputFilename;
    Timer *_defaultTimer;
    std::vector<std::string> _timerNames;
    std::vector<double> _times;
 
    // Holds multiple time values (not flushed after write) to get averaged load values.
    std::deque<double> _timesForAverageBuffer;
    unsigned long _lastTimesOldValueCount{0};  // How many old values _lastTimes holds from before a flush.
    std::vector<double> _global_sum_average_times;
    std::vector<double> _global_max_average_times;
 
    std::vector<double> _sum_times;
    std::vector<double> _global_sum_times;
    std::vector<double> _global_times;
    std::vector<unsigned long> _simsteps;
    std::map<std::string, double> _warninglevels;
 
    std::map<std::string, bool> _incremental;
    std::map<std::string, double> _incremental_previous_times;
    std::vector<double> getAveragedTimes();
};
 
#endif  // SRC_IO_LOADBALANCEWRITER_H_