VectorizationTuner.h

#ifndef SRC_IO_VECTORIZATIONTUNER_H_
#define SRC_IO_VECTORIZATIONTUNER_H_
 
enum MoleculeCntIncreaseTypeEnum{
    linear,      
    exponential, 
    both         
};
 
 
#include <vector>
#include <string>
 
#include "particleContainer/adapter/CellProcessor.h"
#include "particleContainer/adapter/FlopCounter.h"
#include "plugins/PluginBase.h"
#include "ensemble/EnsembleBase.h"
#include "parallel/LoadCalc.h"
 
class Component;
#include "particleContainer/ParticleCellForwardDeclaration.h"
 
 
class VectorizationTuner: public PluginBase {
 
public:
    VectorizationTuner() = default;
 
    ~VectorizationTuner() override = default;
 
    //documentation in PluginBase
    void init(ParticleContainer *particleContainer,
              DomainDecompBase *domainDecomp, Domain *domain) override;
 
    void readXML(XMLfileUnits& xmlconfig) override;
 
    static PluginBase* createInstance() { return new VectorizationTuner(); }
 
    //documentation in PluginBase, does nothing.
    void endStep(ParticleContainer * /*particleContainer*/, DomainDecompBase * /*domainDecomp*/,
                 Domain * /*domain*/, unsigned long /*simstep*/) override {}
 
    //documentation in PluginBase, does nothing.
    void finish(ParticleContainer * /*particleContainer*/,
                DomainDecompBase * /*domainDecomp*/, Domain * /*domain*/) override;
 
    //documentation in PluginBase.
    std::string getPluginName() override {
        return std::string("VectorizationTuner");
    }
 
    void tune(std::vector<Component>& ComponentList, TunerLoad& times, std::vector<int> particleNums, bool generateNewFiles, bool useExistingFiles, bool allowMPIReduce);
 
private:
    std::string _outputPrefix{"MarDyn"};
 
    unsigned int _minMoleculeCnt{2};
 
    unsigned int _maxMoleculeCnt{512};
 
    MoleculeCntIncreaseTypeEnum _moleculeCntIncreaseType{both};
 
    CellProcessor* _cellProcessor{nullptr};
 
    double _cutoffRadius{};
 
    double _LJCutoffRadius{};
 
    unsigned int _numRepetitionsMax{4000000};
 
    static constexpr double _cutoffRadiusBig{5.};
 
    static constexpr double _LJCutoffRadiusBig{5.};
 
    std::unique_ptr<FlopCounter> _flopCounterBigRc;
 
    std::unique_ptr<FlopCounter> _flopCounterNormalRc;
 
    std::unique_ptr<FlopCounter> _flopCounterZeroRc;
 
    /*
     * Writes the given TunerTimes to a file
     */
    void writeFile(const TunerLoad& vecs);
 
    /*
     * Fills the TunerTimes object with values read from a file
     *
     * returns true on success
     */
    bool readFile(TunerLoad& times);
 
    void tune(std::vector<Component>& ComponentList);
 
    void iterate(std::vector<Component>& ComponentList, unsigned int numMols, double& gflopsOwnBig, double& gflopsPairBig, double& gflopsOwnNormal, double& gflopsPairNormalFace,
            double& gflopsPairNormalEdge, double& gflopsPairNormalCorner, double& gflopsOwnZero, double& gflopsPairZero);
 
    void iteratePair (unsigned int numRepetitions,
            ParticleCell& firstCell, ParticleCell& secondCell, double& time);
 
    void iterateOwn (unsigned int numRepetitions,
            ParticleCell& cell, double& time);
 
    void runOwn(CellProcessor& cp, ParticleCell& cell1, unsigned int numRepetitions);
 
    void runPair(CellProcessor& cp, ParticleCell& cell1, ParticleCell& cell2, unsigned int numRepetitions);
 
    void initMeshOfMolecules(const double boxMin[3], const double boxMax[3], Component& comp, ParticleCell& cell1, ParticleCell& cell2);
 
    void initUniformRandomMolecules(Component& comp, ParticleCell& cell, unsigned int numMols);
 
    void initUniformRandomMolecules(Component& comp1, Component& comp2, ParticleCell& cell, unsigned int numMolsFirst, unsigned int numMolsSecond);
 
 
    void moveMolecules(double direction[3], ParticleCell& cell);
 
    void initNormalRandomMolecules(double boxMin[3], double boxMax[3], Component& comp, ParticleCell& cell1, ParticleCell& cell2, unsigned int numMols);
 
    void clearMolecules(ParticleCell& cell);
 
    void initCells(ParticleCell& main, ParticleCell& face, ParticleCell& edge, ParticleCell& corner);
 
    void iterateOwn(unsigned int numRepetitions,
            ParticleCell& cell,
            double& gflopsPair, FlopCounter& flopCounter);
    void iteratePair(unsigned int numRepetitions,
            ParticleCell& firstCell, ParticleCell& secondCell,
            double& gflopsPair, FlopCounter& flopCounter);
 
    class VTWriterI {
    public:
        virtual ~~VTWriterI() = default;
        virtual void initWrite(const std::string& outputPrefix, double cutoffRadius, double LJCutoffRadius,
                double cutoffRadiusBig, double LJCutoffRadiusBig)=0;
        virtual void writeHeader(const std::string& distributionTypeString)=0;
        virtual void write(unsigned int numMols, double gflopsOwnBig, double gflopsPairBig, double gflopsOwnNormal,
                double gflopsPairNormalFace, double gflopsPairNormalEdge, double gflopsPairNormalCorner,
                double gflopsOwnZero, double gflopsPairZero)=0;
        virtual void close()=0;
    protected:
        int _rank;
    };
 
    class VTWriter: public VTWriterI {
    public:
        void initWrite(const std::string& outputPrefix, double cutoffRadius, double LJCutoffRadius,
                double cutoffRadiusBig, double LJCutoffRadiusBig) override;
        void writeHeader(const std::string& distributionTypeString) override;
        void write(unsigned int numMols, double gflopsOwnBig, double gflopsPairBig, double gflopsOwnNormal,
                double gflopsPairNormalFace, double gflopsPairNormalEdge, double gflopsPairNormalCorner,
                double gflopsOwnZero, double gflopsPairZero) override;
        void close() override;
    private:
        ofstream _myfile;
    };
 
    class VTWriterStatistics: public VTWriterI {
    public:
        void initWrite(const std::string& outputPrefix, double cutoffRadius, double LJCutoffRadius,
                double cutoffRadiusBig, double LJCutoffRadiusBig) override;
        void writeHeader(const std::string& distributionTypeString) override;
        void write(unsigned int numMols, double gflopsOwnBig, double gflopsPairBig, double gflopsOwnNormal,
                double gflopsPairNormalFace, double gflopsPairNormalEdge, double gflopsPairNormalCorner,
                double gflopsOwnZero, double gflopsPairZero) override;
        void close() override;
    private:
        void writeStatistics(double input, const std::string& name);
    };
 
    std::unique_ptr<VTWriterI> vtWriter{new VTWriter()};
};
 
#endif  // SRC_IO_VECTORIZATIONTUNER_H_