Compute.h

Go to the documentation of this file.

#ifndef __COMPUTE_H__
#define __COMPUTE_H__
 
#ifdef COOLING_MOLECULARH
#include "Vector3D.h"
#endif /*COOLING_MOLECULARH*/
 
#include "codes.h"
#include "ParallelGravity.h"
 
class State;
class DoubleWalkState;

 
class TreeWalk;
class Opt;

class Compute{
  protected:
  Opt *opt;
  void *computeEntity;
  int activeRung;
  ComputeType type;
 
  Compute(ComputeType t) : type(t) /*state(0)*/{}
 
  public:
  int nActive;  // accumulate total number of active particles.
  void setOpt(Opt *opt);
  // should the dowork method have a state argument?
  // yes, allows listcompute object to keep modifying state
  // which will have within it the checklist, clist and plist
  virtual int doWork(GenericTreeNode *, TreeWalk *tw, State *state, int chunk, int reqID, bool isRoot, bool &didcomp, int awi) = 0;
  // should return int, not bool
  virtual int openCriterion(TreePiece *ownerTP,
                            GenericTreeNode *node, int reqID, State *state) = 0;
 
  virtual void stateReady(State *state, TreePiece *owner, int chunk, int start, int end) {}
 
  virtual void stateReadyPar(TreePiece *tp, int start, int end,
    CkVec<OffsetNode>& clist, CkVec<RemotePartInfo>& rpilist,
    CkVec<LocalPartInfo>& lpilist){}
 
  virtual void fillLists(State *state_, TreePiece *tp, int chunk, int start,
    int end, CkVec<OffsetNode>& clistforb, CkVec<RemotePartInfo>& rplistforb,
    CkVec<LocalPartInfo>& lplistforb) {}

  virtual void init(void *cE, int activeRung, Opt *opt);
  virtual void reassoc(void *cE, int aR, Opt *opt){}
  ComputeType getSelfType(){ return type;}
  OptType getOptType();
  int getActiveRung() {return activeRung;}
 
  // Default impl is empty. Currently only redefined by ListCompute
  // Initializes state.
  virtual void initState(State *state){}
  virtual void startNodeProcessEvent(State *state) {}
  virtual void finishNodeProcessEvent(TreePiece *owner, State *state) {}
  virtual void nodeMissedEvent(int reqID, int chunk, State *state, TreePiece *tp) {}
  virtual void nodeRecvdEvent(TreePiece *owner, int chunk, State *state, int bucket){}
  virtual void recvdParticles(ExternalGravityParticle *egp,int num,int chunk,int reqID,State *state, TreePiece *tp, Tree::NodeKey &remoteBucket){}
  virtual void recvdParticlesFull(GravityParticle *egp,int num,int chunk,int reqID,State *state, TreePiece *tp, Tree::NodeKey &remoteBucket){}
  virtual ~Compute(){}
  virtual void walkDone(State *state){}
  virtual void setComputeEntity(void *ce){
    computeEntity = ce;
  }
 
  virtual void *getComputeEntity(){
    return computeEntity;
  }
 
  virtual State *getNewState(int d1, int d2);
  virtual State *getNewState(int d1);
  virtual State *getNewState();
  virtual void freeState(State *state);
};
 
#include "SSEdefs.h"

class GravityCompute : public Compute{
#ifdef BENCHMARK_TIME_COMPUTE
  double computeTimePart;
  double computeTimeNode;
#endif
 
  void updateInterMass(GravityParticle *p, int start, int end, double mass);
  void updateInterMass(GravityParticle *p, int start, int end, GravityParticle *s, Vector3D<cosmoType> &offset);
 
  public:
  GravityCompute() : Compute(Gravity){
#ifdef BENCHMARK_TIME_COMPUTE
    computeTimePart = 0.0;
    computeTimeNode = 0.0;
#endif
  }
  ~GravityCompute() {
#ifdef BENCHMARK_TIME_COMPUTE
    CkPrintf("Compute time part: %f\n",computeTimePart);
    CkPrintf("Compute time node: %f\n",computeTimeNode);
#endif
  }
 
  int doWork(GenericTreeNode *, TreeWalk *tw, State *state, int chunk, int reqID, bool isRoot, bool &didcomp, int awi);
 
  int openCriterion(TreePiece *ownerTP, GenericTreeNode *node, int reqID, State *state);
  int computeParticleForces(TreePiece *owner, GenericTreeNode *node, ExternalGravityParticle *part, int reqID);
 
  // book keeping on notifications
  void nodeMissedEvent(int reqID, int chunk, State *state, TreePiece *tp);
  void nodeRecvdEvent(TreePiece *owner, int chunk, State *state, int bucket);
  void recvdParticles(ExternalGravityParticle *egp,int num,int chunk,int reqID,State *state, TreePiece *tp, Tree::NodeKey &remoteBucket);
 
  void reassoc(void *cE, int activeRung, Opt *o);
 
};
 
#if INTERLIST_VER > 0
class ListCompute : public Compute{
 
  public:
  ListCompute() : Compute(List) {
  bUseCpu = 0;
  }
 
  int doWork(GenericTreeNode *, TreeWalk *tw, State *state, int chunk, int reqID, bool isRoot, bool &didcomp, int awi);
 
  int openCriterion(TreePiece *ownerTP, GenericTreeNode *node, int reqID, State *state);
 
  // book keeping on notifications
  void nodeMissedEvent(int reqID, int chunk, State *state, TreePiece *tp);
  void nodeRecvdEvent(TreePiece *owner, int chunk, State *state, int bucket);
  void recvdParticles(ExternalGravityParticle *egp,int num,int chunk,int reqID,State *state, TreePiece *tp, Tree::NodeKey &remoteBucket);
 
  void initState(State *state);
 
  void stateReady(State *, TreePiece *, int chunk, int start, int end);
 
  void stateReadyPar(TreePiece *tp, int start, int end,
      CkVec<OffsetNode>& clist, CkVec<RemotePartInfo>& rpilist,
      CkVec<LocalPartInfo>& lpilist);
 
  void fillLists(State *state_, TreePiece *tp, int chunk, int start,
    int end, CkVec<OffsetNode>& clistforb, CkVec<RemotePartInfo>& rplistforb,
    CkVec<LocalPartInfo>& lplistforb);
 
//  void printUndlist(DoubleWalkState *state, int level, TreePiece *tp);
//  void printClist(DoubleWalkState *state, int level, TreePiece *tp);
  void reassoc(void *cE, int activeRung, Opt *o);
  State *getNewState(int d1, int d2);
  State *getNewState(int d1);
  State *getNewState();
  void freeState(State *state);
  void freeDoubleWalkState(DoubleWalkState *state);
  void enableCpu() {bUseCpu = 1;}
 
#ifdef CUDA
#ifdef GPU_LOCAL_TREE_WALK
  void sendLocalTreeWalkTriggerToGpu(State *state, TreePiece *tp, int activeRung, int startBucket, int endBucket);
#endif //GPU_LOCAL_TREE_WALK
  void sendNodeInteractionsToGpu(DoubleWalkState *state, TreePiece *tp);
  void sendPartInteractionsToGpu(DoubleWalkState *state, TreePiece *tp);
#endif
 
  private:
 
  void addChildrenToCheckList(GenericTreeNode *node, int reqID, int chunk, int awi, State *s, CheckList &chklist, TreePiece *tp);
  void addNodeToInt(GenericTreeNode *node, int offsetID, DoubleWalkState *s);
 
  DoubleWalkState *allocDoubleWalkState();
  int bUseCpu;
 
#if defined CHANGA_REFACTOR_PRINT_INTERACTIONS || defined CHANGA_REFACTOR_WALKCHECK_INTERLIST || defined CUDA
  void addRemoteParticlesToInt(ExternalGravityParticle *parts, int n,
                   Vector3D<cosmoType> &offset, DoubleWalkState *s,
                   NodeKey key);
  void addLocalParticlesToInt(GravityParticle *parts, int n,
                  Vector3D<cosmoType> &offset, DoubleWalkState *s,
                  NodeKey key, GenericTreeNode *gtn);
#else
  void addRemoteParticlesToInt(ExternalGravityParticle *parts, int n,
                   Vector3D<cosmoType> &offset, DoubleWalkState *s);
  void addLocalParticlesToInt(GravityParticle *parts, int n,
                  Vector3D<cosmoType> &offset, DoubleWalkState *s);
#endif
 
#ifdef CUDA
  void getBucketParameters(TreePiece *tp, int bucket, int &bucketStart, int &bucketSize, std::map<NodeKey, int>&lpref);
 
  public:
  void resetCudaNodeState(DoubleWalkState *state);
  void resetCudaPartState(DoubleWalkState *state);
  void initCudaState(DoubleWalkState *state, int numBuckets, int nodeThreshold, int partThreshold, bool resume);
  
#endif
 
};
#endif

class PrefetchCompute : public Compute{
 
  public:
  PrefetchCompute() : Compute(Prefetch) {
    computeEntity = 0;
  }
  virtual int doWork(GenericTreeNode *, TreeWalk *tw, State *state, int chunk, int reqID, bool isRoot, bool &didcomp, int awi);
  int openCriterion(TreePiece *ownerTP, GenericTreeNode *node, int reqIDD, State *state);
 
  // book-keeping on notifications
  void startNodeProcessEvent(State *state);
  void finishNodeProcessEvent(TreePiece *owner, State *state);
 
  void recvdParticles(ExternalGravityParticle *egp,int num,int chunk,int reqID,State *state, TreePiece *tp, Tree::NodeKey &remoteBucket);
};

class DummyPrefetchCompute : public PrefetchCompute {
  public:
  int doWork(GenericTreeNode *, TreeWalk *tw, State *state, int chunk, int reqID, bool isRoot, bool &didcomp, int awi){
    return DUMP;
  }
};

 
enum WalkIndices {
    prefetchAwi = 0,
    interListAwi = 1,
    remoteGravityAwi = 2,
    smoothAwi = 3,
    maxAwi = 4
};
    
class ActiveWalk {
  public:
  TreeWalk *tw;
  Compute *c;
  Opt *o;
  State *s;
  
  ActiveWalk(TreeWalk *_tw, Compute *_c, Opt *_o, State *state) : 
      tw(_tw), c(_c), o(_o), s(state){}
  ActiveWalk(){}
};

class TreeNodeWorker {
 
  public:
  virtual bool work(GenericTreeNode *node, int level) = 0;
  virtual void doneChildren(GenericTreeNode *node, int level) {}
};

class RemoteTreeBuilder : public TreeNodeWorker {
  TreePiece *tp;
  bool requestNonLocalMoments; 
 
  public:
  RemoteTreeBuilder(TreePiece *owner, bool req) : 
    tp(owner),
    requestNonLocalMoments(req)
  {}
 
  bool work(GenericTreeNode *node, int level);
  void doneChildren(GenericTreeNode *node, int level);
 
  private:
  void registerNode(GenericTreeNode *node);
 
};

class LocalTreeBuilder : public TreeNodeWorker {
  TreePiece *tp;
 
  public:
  LocalTreeBuilder(TreePiece *owner) :
    tp(owner)
  {}
 
  bool work(GenericTreeNode *node, int level);
  void doneChildren(GenericTreeNode *node, int level);
 
  private:
  void registerNode(GenericTreeNode *node);
};

class LocalTreePrinter : public TreeNodeWorker {
  int index;
  std::ofstream file;
  string description;
 
  void openFile();
 
  public:
  LocalTreePrinter(string d, int idx) : 
    index(idx),
    description(d)
  {
    openFile();
  }
 
  ~LocalTreePrinter(){
    file << "}" << std::endl;
    file.close();
  }
 
  bool work(GenericTreeNode *node, int level);
  void doneChildren(GenericTreeNode *node, int level);
};
 
#ifdef COOLING_MOLECULARH
class LocalLymanWernerDistributor : public TreeNodeWorker {
  /*Defining a new class inherited from TreeNodeWorker to use while distributing LW over a depth-first walk */
  TreePiece *tp; /*Defined in ParallelGravity.h.  Fundamental structure that holds particle and tree data.*/
 
 public:
 /*Constructor.  Only argment is the TreePiece*/
 LocalLymanWernerDistributor(TreePiece *owner) :
  tp(owner)
  {}
 
  bool work(GenericTreeNode *node, int level); /*virtually defined in TreeNodeWorker Class (Compute.h)*/
  void doneChildren(GenericTreeNode *node, int level); /*virtually defined in TreeNodeWorker Class*/
 
  private:
};
#endif /*COOLING_MOLECULARH*/
 
#endif