KDNode.h

#ifndef KDNODE_H_
#define KDNODE_H_
 
// include because of macro KDDIM
#include "parallel/KDDecomposition.h" /* TODO seriously..? */
 
#include "parallel/MPIKDNode.h"
 
#include <vector>
 
class VTKGridWriterImplementation;
 
class KDNode {
 
public:
 
    typedef MPIKDNodePacked MPIKDNode;
 
    KDNode() :_numProcs(0), _nodeID(0), _owningProc(0),
              _child1(nullptr), _child2(nullptr), _load(0.0), _optimalLoadPerProcess(0.0),
          _deviationLowerBound(0.0), _deviation(0.0), _level(0)
    {
    }
 
 
    KDNode(const KDNode& other) : _numProcs(other._numProcs), _nodeID(other._nodeID),
            _owningProc(other._owningProc), _child1(nullptr), _child2(nullptr),
            _load(other._load), _optimalLoadPerProcess(other._optimalLoadPerProcess),
          _deviationLowerBound(other._deviationLowerBound), _deviation(other._deviation),
            _level(other._level)
    {
        for (int dim = 0; dim < KDDIM; dim++) {
            _lowCorner[dim] = other._lowCorner[dim];
            _highCorner[dim] = other._highCorner[dim];
            _coversWholeDomain[dim] = other._coversWholeDomain[dim];
        }
    }
 
    KDNode(int numP, const int low[KDDIM], const int high[KDDIM], int id, int owner, bool coversAll[KDDIM], int level)
    : _numProcs(numP), _nodeID(id), _owningProc(owner),
      _child1(nullptr), _child2(nullptr), _load(0.0), _optimalLoadPerProcess(0.0),
          _deviationLowerBound(0.0), _deviation(0.0), _level(level)
    {
        for (int dim = 0; dim < KDDIM; dim++) {
            _lowCorner[dim] = low[dim];
            _highCorner[dim] = high[dim];
            _coversWholeDomain[dim] = coversAll[dim];
        }
    }
 
    bool equals(KDNode& other);
 
    ~KDNode() {
        delete _child1;
        delete _child2;
    }
 
    KDNode* findAreaForProcess(int rank);
 
    void buildKDTree();
 
    bool isResolvable();
 
    unsigned int getNumMaxProcs();
 
    double calculateAvgLoadPerProc() const {
        return _load / ((double) _numProcs);
    }
 
    void calculateDeviationLowerBound(std::vector<double>* accumulatedProcessorSpeeds = nullptr) {
        double meanProcessorSpeed[] = { 1., 1. };
        double totalMeanProcessorSpeed = 1.;
        if (accumulatedProcessorSpeeds and not accumulatedProcessorSpeeds->empty()) {
            meanProcessorSpeed[0] = ((*accumulatedProcessorSpeeds)[_child2->_owningProc]
                    - (*accumulatedProcessorSpeeds)[_owningProc]) / (_child1->_numProcs);
            meanProcessorSpeed[1] = ((*accumulatedProcessorSpeeds)[_child2->_owningProc + _child2->_numProcs]
                    - (*accumulatedProcessorSpeeds)[_child2->_owningProc]) / (_child2->_numProcs);
            size_t numProcs = accumulatedProcessorSpeeds->size() - 1;
            totalMeanProcessorSpeed = (*accumulatedProcessorSpeeds)[numProcs] / numProcs;
        }
        double child1Dev = _child1->calculateAvgLoadPerProc()
                - _optimalLoadPerProcess * meanProcessorSpeed[0] / totalMeanProcessorSpeed;
        child1Dev = child1Dev * child1Dev;
        double child2Dev = _child2->calculateAvgLoadPerProc()
                - _optimalLoadPerProcess * meanProcessorSpeed[1] / totalMeanProcessorSpeed;
        child2Dev = child2Dev * child2Dev;
        _deviationLowerBound = child1Dev * static_cast<double>( _child1->_numProcs) + child2Dev * static_cast<double>(_child2->_numProcs);
    }
 
    void calculateDeviation(std::vector<double>* processorSpeeds = nullptr, const double &totalMeanProcessorSpeed = 1.) {
        if (_numProcs == 1) {
            double speed = 1.;
            if (processorSpeeds != nullptr && processorSpeeds->size() > (unsigned int)_owningProc) {
                speed = (*processorSpeeds)[_owningProc];
            }
            //_deviation = _load - _optimalLoadPerProcess;
            double dev = _load - _optimalLoadPerProcess * speed / totalMeanProcessorSpeed;
            _deviation = dev * dev;
        } else {
            _deviation = _child1->_deviation + _child2->_deviation;
        }
    }
 
    void getOwningProcs(const int low[KDDIM], const int high[KDDIM], std::vector<int>& procIDs, std::vector<int>& neighbHaloAreas) const;
 
 
    void split(int divDimension, int splitIndex, int numProcsLeft);
 
    void printTree(const std::string& prefix, std::ostream& ostream);
 
    void serialize(const std::string& fileName);
 
    void deserialize(const std::string& fileName);
 
    void plotNode(const std::string& vtkFile, const std::vector<double>* processorSpeeds=nullptr) const;
 
    static void initMPIDataType() {
        MPIKDNode::initDatatype();
    }
 
    static void shutdownMPIDataType() {
        MPIKDNode::shutdownDatatype();
    }
 
    MPIKDNode getMPIKDNode();
 
    int _numProcs;
    int _lowCorner[3];
    int _highCorner[3];
    bool _coversWholeDomain[KDDIM];
 
    int _nodeID;
    int _owningProc; // only used if the node is a leaf
 
    KDNode* _child1;
    KDNode* _child2;
 
    double _load;
    double _optimalLoadPerProcess;
 
    double _deviationLowerBound;
    double _deviation;
 
    int _level;
 
private:
 
    void serialize(std::ostream& file);
 
    void deserialize(std::istream& file);
 
    void plotNode(VTKGridWriterImplementation& writer) const;
 
};
 
#endif /* KDNODE_H_ */