gmpGemaPCR.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2014 by Carlos Augusto Teixera Mendes
** All rights reserved.
**
** This file is part of the "GeMA" software. It's use should respect
** the terms in the license agreement that can be found together
** with this source code.
** It is provided AS IS, with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE.
**
************************************************************************/
 
#ifndef _GEMA_PLUGIN_GEMA_PCR_H_
#define _GEMA_PLUGIN_GEMA_PCR_H_
 
#include "gmpGemaCR.h"
 
class GmpPartitionMethod
{
public:
  GmpPartitionMethod(const QVariantMap& options) : _options(options) {}
 
  virtual bool checkOptions(const GmLogCategory& logger) = 0;
 
  virtual void printParameters(const GmLogCategory& logger) const = 0;
 
  virtual bool partition(GmCellMesh* mesh, int numPartitions, QVector<int>& cellPartition,
                         const GmLogCategory& logger) const = 0;
 
protected:
  const QVariantMap& _options;  
};
 
 
 
template <template <class> class Vector>
class GMP_GEMA_PCR_API_EXPORT GmpGemaPCRBase : public GmpGemaCRBase<Vector, true>
{
public:
  GmpGemaPCRBase(GmSimulationData* simulation, QString id, QString description, const GmLogCategory& logger)
    : GmpGemaCRBase(simulation, id, description, logger), _numPartitions(1), _partition(0),
      _numGlobalNodes(0), _numGlobalGhostNodes(0), _numGlobalCells(0), _partitionMethod(NULL),
      _haloSides(false), _remoteHalo(false), _debugMode(false), _templateDumpData(NULL),
      _templateDumpDataSize(0)
  {}
 
  virtual ~GmpGemaPCRBase();
 
  // Comments on the base class
  virtual const char* pluginType() const { if constexpr(std::is_same<Vector<int>, GmSingleVector<int>>::value) return "pcr"; else return "pcrd"; }
 
  // Comments on the base class
  virtual bool hasCapability(QString capabilityName) const
  {
    return capabilityName == "partitioning" || GmpGemaCRBase<Vector, true>::hasCapability(capabilityName);
  }
 
  virtual bool loadPrivateData(LuaTable& table);
  virtual void printParameters(const GmLogCategory& logger);
 
  // --------------------------------------
  // -- Partition -------------------------
  // --------------------------------------
 
  // Comments on the base class
  virtual int numPartitions()       const { return _numPartitions; } 
  virtual int partition()           const { return _partition; } 
  virtual int numGlobalNodes()      const { assert(_mesh); return _numPartitions > 1 ? _numGlobalNodes : _mesh->numNodes(); }  // Before partitioning, we return the mesh information
  virtual int numGlobalGhostNodes() const { assert(_mesh); return _numPartitions > 1 ? _numGlobalGhostNodes : _mesh->numGhostNodes(); }
  virtual int numGlobalCells()      const { assert(_mesh && dynamic_cast<GmCellMesh*>(_mesh)); return _numPartitions > 1 ? _numGlobalCells : ((GmCellMesh*)_mesh)->numCells(); }
 
  virtual GmPCR::CellClass cellClass      (int cellId) const;
  virtual int              cellClassData  (int cellId) const;
  virtual int              numCellsInClass(GmPCR::CellClass cellClass) const;
  virtual GmPCR::NodeClass nodeClass      (int nodeId) const;
  virtual int              nodeClassData  (int nodeId) const;
  virtual int              numNodesInClass(GmPCR::NodeClass nodeClass, GmCellFillMode mode = GM_CELL_NODES) const;
 
  // Comments on the base class
  virtual int        numRemoteRanks(int templateIndex) const { return _debugMode ? 0    : _classData._rankTemplates[templateIndex].first;  }
  virtual const int* remoteRanks   (int templateIndex) const { return _debugMode ? NULL : _classData._rankTemplates[templateIndex].second; }
 
  virtual bool addPartitionInfoAsMeshAttributes     (QString cellAttrPrefix, QString nodeAttrPrefix);
  virtual bool addDebugPartitionInfoAsMeshAttributes(QString cellAttrPrefix, QString nodeAttrPrefix);
  virtual void printPartitionRankTemplateData       (const GmLogCategory& logger) const;
  virtual void printPartitionClassStatistics        (const GmLogCategory& logger) const;
 
  // -------------------------------------------------
  // Initialization, control and dump API used by the mesh
  // -------------------------------------------------
  virtual bool initPartitions(int numPartitions, int partition);
  virtual bool initNodeMapping(GmValueAccessor* ac, bool ghost, bool* renumbered, 
                               QMap<int, int>& partOrigToLocOrder);
  virtual bool initCellMapping(bool* renumbered, QMap<int, int>& partOrigToLocOrder,
                               QVector<int>& partLocToOrigOrder);
 
  virtual bool addNodes      (int numNodes);
  virtual bool addGhostNodes (int numGhostNodes);
  virtual bool addCells      (int numCells);
 
  virtual void clear();
 
  virtual bool addStateGeometryData    (GmStateDump* state, int groupId);
  virtual bool fillDumpControlMapData  (QVariantMap* map, const GmLogCategory& logger);
  virtual bool dumpControlMapDataLoaded(QVariantMap* map, const GmLogCategory& logger);
 
protected:
 
  virtual size_t partitionMemory() const;
 
private:
  using IntVector = typename GmpGemaCRBase<Vector, true>::IntVector;
 
  using ShortVector = Vector<short int>;
 
  struct ClassData
  {
    ClassData();
    ~ClassData();
 
    size_t usedMemory() const;
    void   clear();
 
    IntVector   _nodes;   
    IntVector   _ghosts;  
    IntVector   _cells;   
 
    ShortVector _nodeClass;  
    ShortVector _ghostClass; 
    ShortVector _cellClass;  
 
    int _nodesPerClass[GM_PCR_NUM_CLASSES]; 
    int _ghostPerClass[GM_PCR_NUM_CLASSES]; 
    int _cellsPerClass[GM_PCR_NUM_CLASSES]; 
 
    QVector<QPair<int, int*>> _rankTemplates;
  };
 
  class RankTemplateBuilder
  {
    public:
      // Constructor. Gets as parameter a reference to the ClassData::_rankTemplates list to build
      RankTemplateBuilder(QVector<QPair<int, int*>>& templateList)
        : _templateList(templateList) {}
      int index(const QSet<int>& rankSet);
    private:
      QVector<QPair<int, int*>>&  _templateList; 
      QMap<quint32, QVector<int>> _listIndex;    
  };
 
  int nodeData(int nodeId) const;
 
  bool classifyNodesAndCells(ClassData* cd, int partition, const QVector<int>& cellPartition) const;
  bool classifyCells        (ClassData* cd, int partition, const QVector<int>& cellPartition, RankTemplateBuilder* builder) const;
  bool classifyNodes        (ClassData* cd, int partition, const QVector<int>& cellPartition, RankTemplateBuilder* builder) const;
 
  bool adjustClassDataNodeOrder(ClassData* cd, bool ghost, const QMap<int, int>& partOrigToLocOrder) const;
  bool adjustClassDataCellOrder(ClassData* cd, const QMap<int, int>& partOrigToLocOrder) const;
 
  template <template<class> class V, class T, class F> bool adjustVector(V<T>& vector, F op) const;
 
  bool addAndInitClassDataVector(ShortVector& v, int numAddedEntries, int val) const;
 
  bool auxTemplateBufferLoaded(const GmLogCategory& logger);
  void releaseDumpMemory();
 
  int _numPartitions;       
  int _partition;           
  int _numGlobalNodes;      
  int _numGlobalGhostNodes; 
  int _numGlobalCells;      
 
  GmpPartitionMethod* _partitionMethod;   
  bool                _haloSides;         
  bool                _remoteHalo;        
  bool                _debugMode;         
 
  QVector<ClassData*> _rankClassData; 
  ClassData           _classData;     
 
  int* _templateDumpData;
 
  int _templateDumpDataSize;
};
 
 
typedef GmpGemaPCRBase<GmSingleVector> GmpGemaPCR;
 
typedef GmpGemaPCRBase<GmDualVector> GmpGemaPCRD;
 
 
#endif