//ParallelGravity.ci

mainmodule ParallelGravity {

  extern module Reductions;

  include "keytype.h";

  readonly CProxy_Main mainChare;
  readonly int verbosity;
  readonly CProxy_TreePiece treeProxy;
#ifdef REDUCTION_HELPER
  readonly CProxy_ReductionHelper reductionHelperProxy;
#endif
  readonly CProxy_LvArray lvProxy;
  readonly CProxy_LvArray smoothProxy;
  readonly CProxy_LvArray gravityProxy;
  readonly CProxy_TreePiece streamingProxy;
  readonly CProxy_CkCacheManager<KeyType> cacheNode;
  readonly CProxy_CkCacheManager<KeyType> cacheGravPart;
  readonly CProxy_CkCacheManager<KeyType> cacheSmoothPart;
  readonly CProxy_DataManager dMProxy;
  readonly CProxy_PETreeMerger peTreeMergerProxy;


  readonly bool _cache;
  readonly int _nocache;
  readonly int _cacheLineDepth;
  readonly unsigned int _yieldPeriod;
  readonly DomainsDec domainDecomposition;
  readonly double dExtraStore;
  readonly double dMaxBalance;
  readonly int peanoKey;
  readonly GenericTrees useTree;
  readonly int _prefetch;
  readonly int _randChunks;
  readonly int _numChunks;
  readonly CkArrayID treePieceID;
  readonly CkGroupID dataManagerID;
  readonly unsigned int numTreePieces;
  readonly unsigned int particlesPerChare;
  readonly unsigned int bucketSize;
  readonly int nIOProcessor;
  readonly int lbcomm_cutoff_msgs;
  // jetley
  readonly int localNodesPerReq;
  readonly int remoteNodesPerReq;
  readonly int remoteResumeNodesPerReq;
  readonly int localPartsPerReq;
  readonly int remotePartsPerReq;
  readonly int remoteResumePartsPerReq;
  readonly double largePhaseThreshold;

  readonly ComlibInstanceHandle cinst1;
  readonly ComlibInstanceHandle cinst2;

  readonly int boundaryEvaluationUE;
  readonly int weightBalanceUE;
  readonly int networkProgressUE;
  readonly int nodeForceUE;
  readonly int partForceUE;

  readonly int tbRecursiveUE;
  readonly int tbFlushRequestsUE;
  readonly int prefetchDoneUE;

#ifdef PUSH_GRAVITY
  readonly CkGroupID ckMulticastGrpId;
#endif

  readonly CProxy_ProjectionsControl prjgrp;

  // number of bins to use for the first
  // iteration of every decomposition step
  readonly int numInitDecompBins;

  readonly bool doDumpLB;
  readonly int lbDumpIteration;
  readonly bool doSimulateLB;

  //message piecedata;
  message dummyMsg;
  message ComputeChunkMsg;

  message ORBSplittersMsg{
    double pos[];
    char dim[];
  };

  message ParticleShuffleMsg {
    GravityParticle particles[];
    extraSPHData pGas[];
    extraStarData pStar[];
  };

#ifdef PUSH_GRAVITY
  message BucketMsg {
    GenericTreeNode buckets[];
    ExternalGravityParticle particles[];
  };
#endif

  PUPable DensitySmoothParams;
  PUPable DenDvDxSmoothParams;
  PUPable DenDvDxNeighborSmParams;
  PUPable MarkSmoothParams;
  PUPable PressureSmoothParams;
  PUPable DistDeletedGasSmoothParams;

  PUPable AccOutputParams;
  PUPable DenOutputParams;
  PUPable HsmOutputParams;
  PUPable PresOutputParams;
  PUPable DivVOutputParams;
  PUPable PDVOutputParams;
  PUPable MuMaxOutputParams;
  PUPable BSwOutputParams;
  PUPable CsOutputParams;
  PUPable EDotOutputParams;
  PUPable Cool0OutputParams;
  PUPable Cool1OutputParams;
  PUPable Cool2OutputParams;
  PUPable DtOutputParams;
  PUPable KeyOutputParams;
  PUPable RungOutputParams;
  PUPable IOrderOutputParams;
  PUPable IGasOrderOutputParams;

  mainchare [migratable] Main {
    entry Main(CkArgMsg*);
    entry [threaded] void setupICs();
    entry [threaded] void initialForces();
    entry [threaded] void doSimulation();
    entry void restart();
    entry void niceExit();
    entry void liveVizImagePrep(liveVizRequestMsg *msg);
  };

  group [migratable] ProjectionsControl {
    entry ProjectionsControl();
    entry [notrace] void on(CkCallback);
    entry [notrace] void off(CkCallback);                     
  };                                                          

#ifdef REDUCTION_HELPER
  group [migratable] ReductionHelper {
    entry ReductionHelper();
    entry void countTreePieces(CkCallback &cb);
    entry [nokeep] void evaluateBoundaries(SFC::Key keys[n], const int n, int isRefine, const CkCallback& cb);
  };
#endif

  chare [migratable] Sorter {
    entry Sorter();

    entry [threaded]
	void startSorting(const CkGroupID& dataManagerID,
        		const double toler,
        		const CkCallback& cb, bool decompose);
    entry void collectEvaluations(CkReductionMsg* m);
    entry void collectORBCounts(CkReductionMsg* m);
    entry void finishPhase(CkReductionMsg* m);
    entry void doORBDecomposition(CkReductionMsg* m);
    entry void readytoSendORB(CkReductionMsg* m);
  };

  nodegroup [migratable] DataManager {
    entry DataManager(const CkArrayID& treePieceID);

    entry void acceptResponsibleIndex(const int responsible[n], const int n,
				      const CkCallback& cb);
    entry void acceptFinalKeys(const SFC::Key keys[n],
        const int responsible[n - 1],
        unsigned int bins[n - 1], const int n,
        const CkCallback& cb);
    entry void collectSplitters(CkReductionMsg* m);
    //entry [local,exclusive] void notifyPresence(int index, Tree::GenericTreeNode *root);
    entry void combineLocalTrees(CkReductionMsg *m);
    entry void clearInstrument(CkCallback &cb);
    entry void initCooling(double dGmPerCcUnit, double dComovingGmPerCcUnit,
		       double dErgPerGmUnit, double dSecUnit, double dKpcUnit,
			 COOLPARAM inParam, const CkCallback& cb);
    entry void dmCoolTableRead(double dTableData[nData], int nData, const CkCallback& cb);
    entry void CoolingSetTime(double z, double dTime, const CkCallback& cb);
    entry void memoryStats(const CkCallback& cb);
    entry void resetReadOnly(Parameters param, const CkCallback &cb);
  };

  array [1D] TreePiece {
    entry TreePiece();
    entry void restart();

    // DEBUGGING
    entry void quiescence();
    entry void memCacheStats(const CkCallback &cb);

    entry void report();

    entry void nextBucket(dummyMsg *m);	
    entry [notrace] void nextBucketSmooth(dummyMsg *msg);
    entry [notrace] void nextBucketReSmooth(dummyMsg *msg);
    entry [notrace] void nextBucketMarkSmooth(dummyMsg *msg);
    //entry void registerWithDataManager(const CkGroupID& dataManagerID,
    //		     		  const CkCallback& cb);
    entry void setPeriodic(int nReplicas, Vector3D<double> fPeriod, int bEwald,
		 double fEwCut, double fEwhCut, int bPeriod);
    entry [notrace] void EwaldInit();
    entry [notrace] void initCoolingData(const CkCallback& cb);
    entry void calculateEwald(dummyMsg *m);
    entry [notrace] void EwaldGPUComplete(); 
    entry [notrace] void EwaldGPU(); 
    entry [notrace] void velScale(double dScale);
    //entry void markPresence(const CkCallback& cb);
    entry void load(const std::string& fn, const CkCallback& cb);
    entry void loadTipsy(const std::string& filename,
        const double dTuFac,
        const CkCallback& cb);
    entry void findTotalMass(CkCallback &cb);
    entry void recvTotalMass(CkReductionMsg *msg);
    entry void setupWrite(int iStage, u_int64_t iPrevOffset,
        const std::string& filename,
        const double dTime, const double dvFac,
        const double duTfac, const int bCool,
        const CkCallback& cb);
    entry void parallelWrite(int iPass, const CkCallback& cb,
			   const std::string& filename, const double dTime,
			   const double dvFac, // scale velocities
			   const double duTFac, // convert temperature
			   const int bCool);
    entry void serialWrite(u_int64_t iPrevOffset, const std::string& filename,
        const double dTime, const double dvFac,
        const double duTfac, const int bCool,
        const CkCallback& cb);
    entry void oneNodeWrite(int iIndex,
			       int iOutParticles,
			       int iOutSPH,
			       int iOutStar,
			       GravityParticle particles[iOutParticles+2], // particles to
						     // write
			       extraSPHData pGas[iOutSPH], // SPH data
			       extraStarData pStar[iOutStar], // Star data
			       int piSPH[iOutSPH], // SPH data offsets
			       int piStar[iOutStar], // Star data offsets
			       const u_int64_t iPrevOffset,
			       const std::string& filename,  // output file
			       const double dTime,      // time or expansion
			       const double dvFac,  // velocity conversion
			     const double duTFac, // temperature conversion
			     const int bCool, const CkCallback& cb);
    entry void reOrder(int64_t nMaxOrder, CkCallback& cb);
    entry void ioShuffle(CkReductionMsg *msg);
    entry void ioAcceptSortedParticles(ParticleShuffleMsg *);
    entry void assignKeys(CkReductionMsg* m);
    entry [nokeep] void evaluateBoundaries(SFC::Key keys[n], const int n, int isRefine, const CkCallback& cb);
    entry void unshuffleParticles(CkReductionMsg* m);
    entry void acceptSortedParticles(ParticleShuffleMsg *);
    //ORB
    entry void initORBPieces(const CkCallback& cb);
    entry void initBeforeORBSend(unsigned int myCount, unsigned int myCountGas,
			     unsigned int myCountStar,
			     const CkCallback& cb, const CkCallback& cback);
    entry void sendORBParticles();
    entry void acceptORBParticles(const GravityParticle particles[n],
				  const int n,
			  	  const extraSPHData pGas[nGasIn],
				  const int nGasIn,
			  	  const extraStarData pStar[nStarIn],
				  const int nStarIn);
    entry void finalizeBoundaries(ORBSplittersMsg *splittersMsg);
    entry void evaluateParticleCounts(ORBSplittersMsg *splittersMsg);

    entry void kick(int iKickRung, double dDelta[MAXRUNG+1], int bClosing,
	    int bNeedVPred, int bGasIsothermal, double duDelta[MAXRUNG+1],
	    const CkCallback& cb);
    entry void initAccel(int iKickRung, const CkCallback& cb);
    entry void adjust(int iKickRung, int bEpsAccStep, int bGravStep,
	      int bSphStep, int bViscosityLimitdt,
	      double dEta, double dEtaCourant, double dEtauDot,
	      double dDelta, double dAccFac,
	      double dCosmoFac, double dhMinOverSoft,
	      int bDoGas,
	      const CkCallback& cb);
    entry void truncateRung(int iCurrMaxRung, const CkCallback& cb);
    entry void rungStats(const CkCallback& cb);
    entry void countActive(int activeRung, const CkCallback& cb);
    entry void drift(double dDelta, int bNeedVPred, int bGasIsoThermal,
		     double dvDelta, double duDelta, int nGrowMass,
		     bool buildTree, const CkCallback& cb);
    entry void calcEnergy(const CkCallback& cb);
    entry void colNParts(const CkCallback &cb);
    entry void newOrder(int64_t nStartSPH, int64_t nStartDark,
		int64_t nStartStar, const CkCallback &cb);
    entry void setNParts(int64_t _nTotalSPH, int64_t _nTotalDark,
		 int64_t _nTotalStar, const CkCallback &cb);
    entry void setSoft(const double dSoft, const CkCallback &cb);
    entry void physicalSoft(const double dSoftMax, const double dFac,
        const int bSoftMaxMul, const CkCallback& cb);
    entry void growMass(int nGrowMass, double dDeltaM, const CkCallback& cb);
    entry void InitEnergy(double dTuFac, double z, double dTime,
			const CkCallback& cb);
    entry void updateuDot(int activeRung, double duDelta[MAXRUNG+1],
    	       		double dTime, double z, int bCool, int bAll,
			int bUpdateState, const CkCallback& cb);
    entry void ballMax(int activeRung, double dFac, const CkCallback& cb);
    entry void sphViscosityLimiter(int bOn, int activeRung,
	const CkCallback& cb);
    entry void getAdiabaticGasPressure(double gamma, double gammam1,
					const CkCallback &cb);
    entry void getCoolingGasPressure(double gamma, double gammam1,
				   const CkCallback &cb);
    entry void FormStars(Stfm param, double dTime, double dDelta, double dCosmoFac,
		       const CkCallback& cb);
    entry void setTypeFromFile(int iSetMask, char file[256],
        const CkCallback& cb);
    entry void getCOM(const CkCallback& cb, int bLiveViz);
    entry void getCOMByType(int iType, const CkCallback& cb, int bLiveViz);
    entry void DumpFrame(InDumpFrame in, const CkCallback& cb, int liveVizDump) ;
    entry void liveVizDumpFrameInit(liveVizRequestMsg * msg);
    entry void setProjections(int bOn);
#ifdef PUSH_GRAVITY
    entry void buildTree(int bucketSize, const CkCallback& cb, bool merge);
#else
    entry void buildTree(int bucketSize, const CkCallback& cb);
#endif

    //entry void collectSplitters(CkReductionMsg* m);
    entry void startOctTreeBuild(CkReductionMsg* m);

    entry void startORBTreeBuild(CkReductionMsg* m);

    entry void startGravity(int activeRung, double myTheta, CkCallback &cb);
#ifdef PUSH_GRAVITY
    entry void startPushGravity(int am, double myTheta);
    entry void recvPushBuckets(BucketMsg *);
    entry void recvPushAccelerations(CkReductionMsg *);
#endif

    entry void startSmooth(CkPointer<SmoothParams>, int iLowhFix, int nSmooth,
				    double dfBall2OverSoft2, CkCallback &cb);
    entry void startReSmooth(CkPointer<SmoothParams>, CkCallback &cb);
    entry void startMarkSmooth(CkPointer<SmoothParams>, CkCallback &cb);
    entry void finishNodeCache(CkCallback &cb);

    entry
#ifndef MERGE_REMOTE_REQUESTS 
    	  [inline]
#endif
	  void requestRemoteMoments(Tree::NodeKey key, int sender);
    entry void receiveRemoteMoments(Tree::NodeKey key, Tree::NodeType type, int firstParticle, int numParticles, MultipoleMoments& moments, OrientedBox<double>& box, OrientedBox<double>& boxBall, unsigned int iParticleTypes);

    //entry void calculateGravityDirect(const CkCallback& cb);
    //entry void fillRequestDirect(GravityRequest req);
    //entry void receiveGravityDirect(const GravityRequest& req);

    //entry void calculateGravityTree(double t, const CkCallback& cb);
    //entry void fillRequestTree(GravityRequest req);	
    //entry void receiveGravityTree(const GravityRequest& req);

    entry [notrace] void commenceCalculateGravityLocal();
    entry [notrace] void calculateGravityLocal();
    entry void calculateGravityRemote(ComputeChunkMsg *msg);

    entry [notrace] void calculateSmoothLocal();
    entry [notrace] void calculateReSmoothLocal();
    entry [notrace] void calculateMarkSmoothLocal();

    entry void finishWalk();
    entry void finishSmoothWalk();
    //entry void fillRequestBucketTree(BucketGravityRequest req);	
    //entry void receiveGravityBucketTree(const BucketGravityRequest& req);

    //entry void FillRequestNode(int retIndex, Tree::NodeKey lookupKey,
    //			   BucketGravityRequest &req);
    entry [expedited] void fillRequestNode(CkCacheRequestMsg<KeyType> *msg);
    //entry [local] void receiveNodeCallback(GenericTreeNode *node, int chunk, int reqID, int awi, void *source);
    //entry void receiveNode(GenericTreeNode node[1],
    //	       unsigned int reqID);
    //entry [inline] void receiveNode_inline(GenericTreeNode node[1],
    //				       unsigned int reqID);
    //entry void fillRequestParticle(int retIndex, int pi,
    //				BucketGravityRequest &req);
    //entry void receiveParticle(GravityParticle part,
    //			   BucketGravityRequest &req);
    entry [expedited] void fillRequestParticles(CkCacheRequestMsg<KeyType> *msg);
    entry [expedited] void fillRequestSmoothParticles(CkCacheRequestMsg<KeyType> *msg);
    entry void flushSmoothParticles(CkCacheFillMsg<KeyType> *msg);
    //entry [local] void receiveParticlesCallback(ExternalGravityParticle *egp, int num, int chunk, int reqID, Tree::NodeKey &remoteBucket, int awi, void *source);
    //entry [local] void receiveParticlesFullCallback(GravityParticle *egp, int num, int chunk, int reqID, Tree::NodeKey &remoteBucket, int awi, void *source);
    //entry void fillRequestParticles(SFC::Key key,int retIndex, int begin,int end,
    //				unsigned int reqID);
    //entry void receiveParticles(ExternalGravityParticle part[num],int num,int chunk,
    //			    unsigned int reqID);
    //entry [inline] void receiveParticles_inline(GravityParticle part[num],int num,
    //					    unsigned int reqID);

    // jetley
    entry void startlb(CkCallback &cb, int activeRung);
    entry void ResumeFromSync();
    //jetley
    entry void receiveProxy(CkGroupID);
    entry void doAtSync();

    entry void outputAccelerations(OrientedBox<double> accelerationBox, const std::string& suffix, const CkCallback& cb);
    entry void outputASCII(CkReference<OutputParams>, int bParaWrite,
			   const CkCallback& cb);
    entry void oneNodeOutVec(CkReference<OutputParams>, Vector3D<double> avOut[nPart],
			   int nPart, int iIndex, int bDone,
			   CkCallback& cb) ;
    entry void oneNodeOutArr(CkReference<OutputParams>, double adOut[nPart],
			   int nPart, int iIndex, int bDone,
			   CkCallback& cb) ;
    entry void outputIntASCII(CkReference<OutputIntParams>, int bParaWrite,
			      const CkCallback& cb);
    entry void oneNodeOutIntArr(CkReference<OutputIntParams>, int aiOut[nPart],
				int nPart, int iIndex, CkCallback& cb);
    entry void outputStatistics(const CkCallback& cb);
    //entry void getPieceValues(piecedata *totaldata);
    entry void collectStatistics(CkCallback &cb);

    // jetley - cuda
    entry void continueStartRemoteChunk(int chunk);
    entry void continueWrapUp();

    // jetley - balancing before initial forces
    entry void balanceBeforeInitialForces(CkCallback &cb); 

  };

  array [1D] LvArray {
      entry LvArray();
  };

  group [migratable] PETreeMerger {
    entry PETreeMerger();
  };

  initproc void registerStatistics();
};