Sorter.h

Go to the documentation of this file.

 
#ifndef SORTER_H
#define SORTER_H
 
#include <list>
#include <vector>
#include <set>
#include <numeric>
 
#include "ParallelGravity.h"

struct OctDecompNode {
  static int maxNumChildren;
  static int lgMaxNumChildren;
 
  OctDecompNode() : children(NULL), nchildren(0), nparticles(0) 
  {
  }
 
  NodeKey key;
  
  OctDecompNode *children;
  int nchildren;
 
  int64_t nparticles;
 
  void makeSubTree(int refineLevel, CkVec<OctDecompNode*> *active);
  int64_t buildCounts();
  void deleteBeneath();
  void combine(int thresh, vector<NodeKey> &finalKeys, vector<uint64_t> &counts);
  void getLeafNodes(CkVec<OctDecompNode*> *activeNodes);
};

class Sorter : public CBase_Sorter {
 
        double decompTime;
    int64_t numKeys;
    int numChares;
    std::vector<int> chareIDs;
    std::vector<int> availableChares;
    // Total size of the keys allocated (allows a margin to increase)
    //int keysSize;

    double tolerance;
    int closeEnough;
    int numIterations;
    bool sorted;
 
    std::vector<NodeKey> nodeKeys;
    std::vector<uint64_t> binCounts;
    std::vector<unsigned int> binCountsGas;
    std::vector<unsigned int> binCountsStar;
    int numCounts;
    std::vector<SFC::Key> keyBoundaries;
        std::vector<uint64_t> accumulatedBinCounts;
    std::vector<SFC::Key> splitters;
 
        CkBitVector binsToSplit;
    int64_t *goals;
        int numGoalsPending;
    
    CProxy_DataManager dm;
    CkCallback sortingCallback;

    int joinThreshold, splitThreshold;
    int refineLevel;
 
        // root of the full tree of node keys for decomposition
        OctDecompNode *root;
        // node keys for the initial bins
        OctDecompNode *decompRoots;
        int numDecompRoots;
        CkVec<OctDecompNode*> *activeNodes;
        CkVec<OctDecompNode*> *tmpActiveNodes;
    
  typedef struct DivData{
    OrientedBox<float> boundingBox;
    double curLow;
    double curHigh;
    double curDivision;
    char curDim;
  } ORBData;

  std::list<ORBData> orbData;
 
    
        CkVec<int> zeros;
        CkVec<NodeKey> nodesOpened;
 
    void adjustSplitters();
    bool refineOctSplitting(int n, int64_t *count);
    
public:
    
    Sorter() {
          root = NULL;
          decompRoots = NULL;
          numDecompRoots = 0;
      joinThreshold = 0;
 
          activeNodes = new CkVec<OctDecompNode*>;
          tmpActiveNodes = new CkVec<OctDecompNode*>;
 
          chareIDs.resize(numTreePieces, 1);
          chareIDs[0] = 0;
          partial_sum(chareIDs.begin(), chareIDs.end(), chareIDs.begin());
    };
    Sorter(CkMigrateMessage* m) : CBase_Sorter(m) {
          root = NULL;
          decompRoots = NULL;
          numDecompRoots = 0;
      joinThreshold = 0;
 
          chareIDs.resize(numTreePieces, 1);
          chareIDs[0] = 0;
          partial_sum(chareIDs.begin(), chareIDs.end(), chareIDs.begin());
    };

    void startSorting(const CkGroupID& dataManagerID, const double toler, const CkCallback& cb, bool decompose);
    void convertNodesToSplitters();
    SFC::Key * convertNodesToSplittersRefine(int num, NodeKey* keys);
    //void convertNodesToSplittersNoZeros(int num, NodeKey* nodeKeys, CkVec<int> &zero);
    void collectEvaluations(CkReductionMsg* m);
    void collectEvaluationsSFC(CkReductionMsg* m);
    void collectEvaluationsOct(CkReductionMsg* m);
 
  //ORB Decomposition
  void doORBDecomposition(CkReductionMsg* m);
  void finishPhase(CkReductionMsg *m);
  void collectORBCounts(CkReductionMsg* m);
  void readytoSendORB(CkReductionMsg* m);
  //void sendBoundingBoxes(CkReductionMsg* m);
};
 
#endif //SORTER_H