FlopCounter.h

Go to the documentation of this file.

 
#ifndef FLOPCOUNTER_H_
#define FLOPCOUNTER_H_
 
#include "CellProcessor.h"
#include <memory>
#include <vector>
#include <stddef.h>
#include <string>
#include <sstream>
 
#include "molecules/MoleculeForwardDeclaration.h"
 
class CellDataSoA;
class CellDataSoARMM;
 
class FlopCounter: public CellProcessor {
public:
    FlopCounter(double cutoffRadius, double LJcutoffRadius);
 
    ~FlopCounter();
 
    void initTraversal();
 
    void preprocessCell(ParticleCell& cell) {}
        
 
    double processSingleMolecule(Molecule* /*m1*/, ParticleCell& /*cell2*/) { return 0.0; }  // why 0.0 flops???
 
    void processCell(ParticleCell& cell);
 
        void processCellPair(ParticleCell& c1, ParticleCell& c2, bool sumAll = false);
        
    void postprocessCell(ParticleCell& cell) {}
 
    void endTraversal();
 
    double getTotalFlopCount() const {
        return _totalFlopCount;
    }
 
    double getTotalMoleculeDistanceFlopCount() const {
        return _currentCounts.getMoleculeDistanceFlops();
    }
 
    void resetCounters() {
        _currentCounts.clear();
//      _totalCounts.clear();
        _totalFlopCount = 0.;
        _myFlopCount = 0.;
    }
 
    double getMyFlopCount() const {
        return _myFlopCount;
    }
 
    void printStats() const;
 
private:
    template<class ForcePolicy, bool CalculateMacroscopic>
    void _calculatePairs(const CellDataSoA & soa1, const CellDataSoA & soa2);
    template<class ForcePolicy, bool CalculateMacroscopic>
    void _calculatePairs(const CellDataSoARMM & soa1, const CellDataSoARMM & soa2);
 
    void handlePair(const Molecule& Mi, const Molecule& Mj,
            bool addMacro = true);
 
    // used for indices within an array!
    enum PotentialIndices {
        I_LJ = 0,
        I_CHARGE,
        I_CHARGE_DIPOLE,
        I_DIPOLE,
        I_CHARGE_QUADRUPOLE,
        I_DIPOLE_QUADRUPOLE,
        I_QUADRUPOLE,
        NUM_POTENTIALS
    };
 
    class _PotentialCounts {
    public:
        void init(const std::string& n, int kM, int mM, int sFTM, int sMM) {
            _name = n;
            clear();
            _kernelMultiplier = kM;
            _macroMultiplier = mM;
            _sumForceTorqueMultiplier = sFTM;
            _sumMacroMultiplier = sMM;
        }
        void clear() {
            _numKernelCalls = 0.0;
            _numMacroCalls = 0.0;
        }
        void addPotentialCounts(const _PotentialCounts& pc) {
            _numKernelCalls += pc._numKernelCalls;
            _numMacroCalls += pc._numMacroCalls;
        }
        void addKernelAndMacro(double valueBoth, bool addMacro) {
            _numKernelCalls += valueBoth;
            if (addMacro)
                _numMacroCalls += valueBoth;
        }
        void collCommAppend();
        void collCommGet();
        double getKernelAndMacroFlops() const {
            return _numKernelCalls * _kernelMultiplier + _numMacroCalls * _macroMultiplier;
        }
        double getForceTorqueSums() const {
            return _numKernelCalls * _sumForceTorqueMultiplier;
        }
        double getMacroValueSums() const {
            return _numMacroCalls * _sumMacroMultiplier;
        }
        std::string printNameKernelAndMacroCalls() const {
            std::ostringstream ostr;
 
            if (_numKernelCalls == 0) { return ostr.str(); } // potential is very likely not present
 
            ostr << " " << _name
                << ": kernel calls: " << _numKernelCalls
                << " macro calls: " << _numMacroCalls
                << std::endl;
            return ostr.str();
        }
 
        /* Fields */
        double _numKernelCalls;
        double _numMacroCalls;
 
        /* Multipliers */
        int _kernelMultiplier;
        int _macroMultiplier;
        int _sumForceTorqueMultiplier;
        int _sumMacroMultiplier;
 
        /* name */
        std::string _name;
    };
 
    class _Counts {
    public:
        _Counts();
        void clear() {
            _moleculeDistances = 0;
 
            for (int i = 0; i < NUM_POTENTIALS; ++i) {
                _potCounts[i].clear();
            }
        }
        void addCounts(const _Counts& c) {
            _moleculeDistances += c._moleculeDistances;
 
            for (int i = 0; i < NUM_POTENTIALS; ++i) {
                _potCounts[i].addPotentialCounts(c._potCounts[i]);
            }
        }
        void allReduce();
        double sumKernelCalls() const {
            double ret = 0.;
            for (int i = 0; i < NUM_POTENTIALS; ++i) {
                ret += _potCounts[i]._numKernelCalls;
            }
            return ret;
        }
        double sumMacros() const {
            double ret = 0.;
            for (int i = 0; i < NUM_POTENTIALS; ++i) {
                ret += _potCounts[i]._numMacroCalls;
            }
            return ret;
        }
        void print() const;
 
        double getMoleculeDistanceFlops() const {
            return _moleculeDistances * _distanceMultiplier;
        }
        double getCenterDistanceFlops() const {
            return sumKernelCalls() * _distanceMultiplier;
        }
        double getForceTorqueSumFlops() const {
            double ret = 0.;
            for (int i = 0; i < NUM_POTENTIALS; ++i) {
                ret += _potCounts[i].getForceTorqueSums();
            }
            return ret;
        }
        double getMacroValueSumFlops() const {
            double ret = 0.;
            for (int i = 0; i < NUM_POTENTIALS; ++i) {
                ret += _potCounts[i].getMacroValueSums();
            }
            return ret;
        }
        double getTotalFlops() const {
            double ret = getMoleculeDistanceFlops() + getCenterDistanceFlops();
            for (int i = 0; i < NUM_POTENTIALS; ++i) {
                ret += _potCounts[i].getKernelAndMacroFlops();
            }
            ret += getForceTorqueSumFlops() + getMacroValueSumFlops();
            return ret;
        }
        void addKernelAndMacro(PotentialIndices i, double valueBoth, bool addMacro) {
            _potCounts[i].addKernelAndMacro(valueBoth, addMacro);
        }
        void initPotCounter(PotentialIndices i, const std::string& n, int kM, int mM, int sFTM, int sMM) {
            _potCounts[i].init(n, kM, mM, sFTM, sMM);
        }
 
        /* Fields which are summed explicitly */
        double _moleculeDistances;
        int _distanceMultiplier;
 
        _PotentialCounts _potCounts[NUM_POTENTIALS];
    };
 
    std::vector<_Counts *> _threadData;
 
    _Counts _currentCounts;
//  _Counts _totalCounts; TODO: is this needed?
    double _totalFlopCount;
    double _myFlopCount;
    bool _synchronized;
};
 
#endif /* FLOPCOUNTER_H_ */