Commit 5b748b7c authored by hrchilds's avatar hrchilds

I renamed avtStreamline to be avtIntegralCurve and all of the avt*SLAlgo's to be avt*ICAlgo's.


git-svn-id: http://visit.ilight.com/svn/visit/trunk/src@11580 18c085ea-50e0-402c-830e-de6fd14e8384
parent 961e71f4
......@@ -42,6 +42,9 @@
# Hank Childs, Sat Jun 5 19:03:22 CDT 2010
# Add avtPICSFilter.
#
# Hank Childs, Sun Jun 6 14:54:08 CDT 2010
# Renamed avt*SLAlgorithm to avt*ICAlgorithm.
#
#****************************************************************************/
SET(AVTFILTERS_SOURCES
......@@ -56,6 +59,7 @@ avtFacelistFilter.C
avtFeatureEdgesFilter.C
avtGhostZoneAndFacelistFilter.C
avtGhostZoneFilter.C
avtICAlgorithm.C
avtImageCommunicator.C
avtImageCompositer.C
avtLinearTransformFilter.C
......@@ -63,11 +67,11 @@ avtLineoutFilter.C
avtLineScanFilter.C
avtLineToPolylineFilter.C
avtMassVoxelExtractor.C
avtMasterSlaveSLAlgorithm.C
avtMasterSlaveICAlgorithm.C
avtMeshLogFilter.C
avtNamedSelectionFilter.C
avtParDomSLAlgorithm.C
avtParSLAlgorithm.C
avtParDomICAlgorithm.C
avtParICAlgorithm.C
avtPICSFilter.C
avtPointToGlyphFilter.C
avtRayCompositer.C
......@@ -76,10 +80,9 @@ avtResampleFilter.C
avtSamplePointCommunicator.C
avtSamplePointExtractor.C
avtSamplePointToSurfaceFilter.C
avtSerialSLAlgorithm.C
avtSerialICAlgorithm.C
avtShiftCenteringFilter.C
avtSimilarityTransformFilter.C
avtSLAlgorithm.C
avtSmoothPolyDataFilter.C
avtStreamlineFilter.C
avtStreamlinePolyDataFilter.C
......
......@@ -37,17 +37,17 @@
*****************************************************************************/
// ************************************************************************* //
// avtSLAlgorithm.h //
// avtICAlgorithm.h //
// ************************************************************************* //
#ifndef AVT_SL_ALGORITHM_H
#define AVT_SL_ALGORITHM_H
#ifndef AVT_IC_ALGORITHM_H
#define AVT_IC_ALGORITHM_H
#include <avtPICSFilter.h>
#include "avtStreamline.h"
#include "avtIntegralCurve.h"
// ****************************************************************************
// Class: avtSLAlgorithm
// Class: avtICAlgorithm
//
// Purpose:
// Abstract base class for streamline algorithms.
......@@ -95,22 +95,26 @@
// particle advection, as opposed to streamlines. Also change reference
// from avtStreamlineFilter to avtPICSFilter.
//
// Hank Childs, Sun Jun 6 14:54:08 CDT 2010
// Rename class "IC" from "SL", to reflect the emphasis on integral curves,
// as opposed to streamlines.
//
// ****************************************************************************
class avtSLAlgorithm
class avtICAlgorithm
{
public:
avtSLAlgorithm( avtPICSFilter *slFilter );
virtual ~avtSLAlgorithm();
avtICAlgorithm( avtPICSFilter *picsFilter );
virtual ~avtICAlgorithm();
//Execution of the algorithm.
virtual void Initialize(std::vector<avtStreamline *> &);
virtual void Initialize(std::vector<avtIntegralCurve *> &);
void Execute();
virtual void ResetIntegralCurvesForContinueExecute() = 0;
virtual void PostExecute();
virtual void GetTerminatedICs(vector<avtStreamline *> &v);
virtual void AddIntegralCurves(std::vector<avtStreamline*> &sls) = 0;
virtual void DeleteIntegralCurves(std::vector<int> &slIDs);
virtual void GetTerminatedICs(vector<avtIntegralCurve *> &v);
virtual void AddIntegralCurves(std::vector<avtIntegralCurve*> &ics) = 0;
virtual void DeleteIntegralCurves(std::vector<int> &icIDs);
protected:
virtual void RunAlgorithm() = 0;
......@@ -118,7 +122,7 @@ class avtSLAlgorithm
virtual void PostRunAlgorithm() {}
avtPICSFilter *picsFilter;
std::list<avtStreamline *> terminatedICs;
std::list<avtIntegralCurve *> terminatedICs;
int numDomains, numTimeSteps, numSeedPoints;
virtual const char* AlgoName() const = 0;
......@@ -126,8 +130,8 @@ class avtSLAlgorithm
avtIVPSolver * GetSolver() {return picsFilter->solver; }
virtual bool PointInDomain(avtVector &pt, DomainType &dom)
{ return picsFilter->avtPICSFilter::PointInDomain(pt, dom); }
virtual void AdvectParticle(avtStreamline *sl);
vtkDataSet *GetDomain(avtStreamline *sl);
virtual void AdvectParticle(avtIntegralCurve *ic);
vtkDataSet *GetDomain(avtIntegralCurve *ic);
vtkDataSet *GetDomain(const DomainType &dom,
double X=0, double Y=0, double Z=0);
virtual bool DomainLoaded(DomainType &dom) const
......@@ -140,13 +144,13 @@ class avtSLAlgorithm
int DomCacheSize() const { return picsFilter->cacheQLen; }
//Utility functions.
virtual void SortIntegralCurves(std::list<avtStreamline *> &);
virtual void SortIntegralCurves(std::vector<avtStreamline *> &);
virtual void SortIntegralCurves(std::list<avtIntegralCurve *> &);
virtual void SortIntegralCurves(std::vector<avtIntegralCurve *> &);
//Statistics and timers.
class SLStatistics
class ICStatistics
{
public:
SLStatistics(std::string s="")
ICStatistics(std::string s="")
{
nm = s;
value = 0.0;
......@@ -158,7 +162,7 @@ class avtSLAlgorithm
float value;
std::string nm;
friend ostream& operator<<(std::ostream &out, const avtSLAlgorithm::SLStatistics &s)
friend ostream& operator<<(std::ostream &out, const avtICAlgorithm::ICStatistics &s)
//friend ostream& operator<<(std::ostream &out)
{
out<<s.nm<<" V: "<<s.value<<" "<<s.total<<" ["<<s.min<<", "<<s.max<<", "<<s.mean<<" : "<<s.sigma<<"]";
......@@ -171,7 +175,7 @@ class avtSLAlgorithm
virtual void CompileTimingStatistics();
virtual void CompileCounterStatistics();
virtual void CalculateExtraTime();
virtual void ComputeStatistic(SLStatistics &stats);
virtual void ComputeStatistic(ICStatistics &stats);
virtual void ComputeDomainLoadStatistic();
virtual void ReportStatistics(ostream &os);
virtual void ReportTimings(ostream &os, bool totals);
......@@ -179,19 +183,19 @@ class avtSLAlgorithm
void PrintTiming(ostream &os,
char *str,
const SLStatistics &s,
const SLStatistics &t,
const ICStatistics &s,
const ICStatistics &t,
bool total);
void PrintCounter(ostream &os,
char *str,
const SLStatistics &s,
const ICStatistics &s,
bool total);
//Timers.
SLStatistics TotalTime, IOTime, IntegrateTime, SortTime,
ICStatistics TotalTime, IOTime, IntegrateTime, SortTime,
ExtraTime;
//Counters.
SLStatistics IntegrateCnt, DomLoadCnt, DomPurgeCnt;
ICStatistics IntegrateCnt, DomLoadCnt, DomPurgeCnt;
//Special counters.
int domainsUsed, totDomainsLoaded, domainLoadedMin, domainLoadedMax;
......
......@@ -37,20 +37,20 @@
*****************************************************************************/
// ************************************************************************* //
// avtMasterSlaveSLAlgorithm.h //
// avtMasterSlaveICAlgorithm.h //
// ************************************************************************* //
#ifndef AVT_MASTER_SLAVE_SL_ALGORITHM_H
#define AVT_MASTER_SLAVE_SL_ALGORITHM_H
#ifndef AVT_MASTER_SLAVE_IC_ALGORITHM_H
#define AVT_MASTER_SLAVE_IC_ALGORITHM_H
#include "avtParSLAlgorithm.h"
#include "avtParICAlgorithm.h"
#ifdef PARALLEL
class SlaveInfo;
// ****************************************************************************
// Class: avtMasterSlaveSLAlgorithm
// Class: avtMasterSlaveICAlgorithm
//
// Purpose:
// Abstract base class for master-slave algorithm.
......@@ -80,22 +80,26 @@ class SlaveInfo;
// particle advection, as opposed to streamlines. Also change reference
// from avtStreamlineFilter to avtPICSFilter.
//
// Hank Childs, Sun Jun 6 14:54:08 CDT 2010
// Rename class "IC" from "SL", to reflect the emphasis on integral curves,
// as opposed to streamlines.
//
// ****************************************************************************
class avtMasterSlaveSLAlgorithm : public avtParSLAlgorithm
class avtMasterSlaveICAlgorithm : public avtParICAlgorithm
{
public:
avtMasterSlaveSLAlgorithm(avtPICSFilter *slFilter,
avtMasterSlaveICAlgorithm(avtPICSFilter *picsFilter,
int maxCount);
virtual ~avtMasterSlaveSLAlgorithm();
virtual ~avtMasterSlaveICAlgorithm();
virtual void Initialize(std::vector<avtStreamline *> &);
virtual void Initialize(std::vector<avtIntegralCurve *> &);
virtual const char* AlgoName() const {return "MasterSlave";}
virtual void ResetIntegralCurvesForContinueExecute();
virtual void AddIntegralCurves(std::vector<avtStreamline*> &sls);
virtual void AddIntegralCurves(std::vector<avtIntegralCurve*> &ics);
static avtMasterSlaveSLAlgorithm* Create(avtPICSFilter *slFilter,
static avtMasterSlaveICAlgorithm* Create(avtPICSFilter *picsFilter,
int maxCount,
int rank,
int nProcs,
......@@ -122,16 +126,16 @@ class avtMasterSlaveSLAlgorithm : public avtParSLAlgorithm
int sleepMicroSec;
void Sleep();
static int MSG_STATUS, MSG_DONE, MSG_SEND_SL,
MSG_LOAD_DOMAIN, MSG_SEND_SL_HINT,
static int MSG_STATUS, MSG_DONE, MSG_SEND_IC,
MSG_LOAD_DOMAIN, MSG_SEND_IC_HINT,
MSG_FORCE_SEND_STATUS, MSG_MASTER_STATUS,
MSG_OFFLOAD_SL;
MSG_OFFLOAD_IC;
//Statistics and coutners.
int latencyTimer;
std::vector<double> latencyHistory;
SLStatistics SleepTime, LatencyTime, MaxLatencyTime;
SLStatistics SleepCnt, LatencySavingCnt, OffloadCnt;
ICStatistics SleepTime, LatencyTime, MaxLatencyTime;
ICStatistics SleepCnt, LatencySavingCnt, OffloadCnt;
virtual void CompileTimingStatistics();
virtual void CompileCounterStatistics();
virtual void CalculateExtraTime();
......@@ -141,7 +145,7 @@ class avtMasterSlaveSLAlgorithm : public avtParSLAlgorithm
// ****************************************************************************
// Class: avtMasterSLAlgorithm
// Class: avtMasterICAlgorithm
//
// Purpose:
// Master portion of the master-slave algorithm.
......@@ -165,19 +169,19 @@ class avtMasterSlaveSLAlgorithm : public avtParSLAlgorithm
//
// ****************************************************************************
class avtMasterSLAlgorithm : public avtMasterSlaveSLAlgorithm
class avtMasterICAlgorithm : public avtMasterSlaveICAlgorithm
{
public:
avtMasterSLAlgorithm(avtPICSFilter *slFilter,
avtMasterICAlgorithm(avtPICSFilter *picsFilter,
int maxCount,
int workGrpSz,
std::vector<int> &slaves,
int master,
std::vector<int> &masters);
virtual ~avtMasterSLAlgorithm();
virtual ~avtMasterICAlgorithm();
virtual const char* AlgoName() const {return "MasterSlave";}
virtual void Initialize(std::vector<avtStreamline *> &);
virtual void Initialize(std::vector<avtIntegralCurve *> &);
protected:
virtual void RunAlgorithm();
......@@ -188,7 +192,7 @@ class avtMasterSLAlgorithm : public avtMasterSlaveSLAlgorithm
virtual void SendStatus(bool forceSend=false);
virtual void ProcessSlaveUpdate(std::vector<int> &);
virtual void ProcessMasterUpdate(std::vector<int> &);
virtual void ProcessOffloadSL(std::vector<int> &);
virtual void ProcessOffloadIC(std::vector<int> &);
virtual void ProcessNewIntegralCurves();
virtual void ManageWorkgroup();
virtual void ManageSlaves();
......@@ -197,14 +201,14 @@ class avtMasterSLAlgorithm : public avtMasterSlaveSLAlgorithm
virtual void CompileCounterStatistics();
virtual void ReportCounters(ostream &os, bool totals);
int workGroupActiveSLs, workGroupSz;
int workGroupActiveICs, workGroupSz;
bool done, slaveUpdate, masterUpdate;
int case1Cnt, case2Cnt, case3ACnt, case3BCnt, case3CCnt, case4ACnt, case4BCnt,
case5ACnt, case5BCnt, case6Cnt;
int master;
std::vector<SlaveInfo> slaveInfo, masterInfo;
std::vector<int> slDomCnts, domLoaded, slackers;
std::list<avtStreamline *> activeSLs;
std::vector<int> icDomCnts, domLoaded, slackers;
std::list<avtIntegralCurve *> activeICs;
void SendAllSlavesMsg(int msg);
void SendAllSlavesMsg(std::vector<int> &msg);
......@@ -229,7 +233,7 @@ class avtMasterSLAlgorithm : public avtMasterSlaveSLAlgorithm
// ****************************************************************************
// Class: avtSlaveSLAlgorithm
// Class: avtSlaveICAlgorithm
//
// Purpose:
// Slave portion of the master-slave algorithm.
......@@ -250,15 +254,15 @@ class avtMasterSLAlgorithm : public avtMasterSlaveSLAlgorithm
//
// ****************************************************************************
class avtSlaveSLAlgorithm : public avtMasterSlaveSLAlgorithm
class avtSlaveICAlgorithm : public avtMasterSlaveICAlgorithm
{
public:
avtSlaveSLAlgorithm(avtPICSFilter *slFilter,
avtSlaveICAlgorithm(avtPICSFilter *picsFilter,
int maxCount,
int masterRank);
virtual ~avtSlaveSLAlgorithm();
virtual ~avtSlaveICAlgorithm();
virtual void Initialize(std::vector<avtStreamline *> &);
virtual void Initialize(std::vector<avtIntegralCurve *> &);
virtual void SendStatus(bool forceSend=false);
virtual void UpdateStatus();
......@@ -268,10 +272,10 @@ class avtSlaveSLAlgorithm : public avtMasterSlaveSLAlgorithm
int master, numTerminated, timeout;
bool workToDo;
std::vector<int> status, prevStatus;
std::list<avtStreamline *> activeSLs, oobSLs;
std::list<avtIntegralCurve *> activeICs, oobICs;
void ProcessMessages(bool &done, bool &newMsg);
void HandleLatencyTimer(int activeSLCnt,
void HandleLatencyTimer(int activeICCnt,
bool checkMaxLatency=true);
};
......@@ -297,15 +301,15 @@ class SlaveInfo
SlaveInfo( int r, int nDomains );
~SlaveInfo() {}
void AddSL(int slDomain, int domCache);
void LoadDom( int slDomain );
void RemoveSL( int dom );
void AddIC(int icDomain, int domCache);
void LoadDom( int icDomain );
void RemoveIC( int dom );
void Update( vector<int> &status, bool debug=false );
void Reset() { justUpdated = false; }
void Debug();
bool justUpdated, initialized;
int canGive, canAccept, slCount, slLoadedCount, slOOBCount, rank;
int canGive, canAccept, icCount, icLoadedCount, icOOBCount, rank;
int domLoadedCount;
vector<int> domainCnt;
vector<bool> domainLoaded;
......
This diff is collapsed.
......@@ -43,7 +43,7 @@
#ifndef AVT_PICS_FILTER_H
#define AVT_PICS_FILTER_H
#include <avtStreamline.h>
#include <avtIntegralCurve.h>
#include <avtDatasetOnDemandFilter.h>
#include <avtDatasetToDatasetFilter.h>
#include <avtIVPDopri5.h>
......@@ -58,7 +58,7 @@
class vtkVisItCellLocator;
class DomainType;
class avtSLAlgorithm;
class avtICAlgorithm;
#define STREAMLINE_TERMINATE_DISTANCE 0
#define STREAMLINE_TERMINATE_TIME 1
......@@ -86,6 +86,12 @@ class avtSLAlgorithm;
// Programmer: Hank Childs (extracted base class from avtStreamlineFilter)
// Creation: June 5, 2010
//
// Modifications:
//
// Hank Childs, Sun Jun 6 15:26:15 CDT 2010
// Rename all methods and data members to reflect integral curves, not
// streamlines.
//
// ****************************************************************************
class AVTFILTERS_API avtPICSFilter :
......@@ -100,8 +106,8 @@ class AVTFILTERS_API avtPICSFilter :
virtual const char *GetDescription(void)
{ return "Advecting particles"; };
virtual avtStreamline *CreateIntegralCurve() = 0;
virtual avtStreamline *CreateIntegralCurve(
virtual avtIntegralCurve *CreateIntegralCurve() = 0;
virtual avtIntegralCurve *CreateIntegralCurve(
const avtIVPSolver* model,
const double& t_start,
const avtVector &p_start, int ID) = 0;
......@@ -130,7 +136,7 @@ class AVTFILTERS_API avtPICSFilter :
double termination;
int integrationDirection;
int dataSpatialDimension;
avtSLAlgorithm *slAlgo;
avtICAlgorithm *icAlgo;
avtContract_p lastContract;
......@@ -169,8 +175,8 @@ class AVTFILTERS_API avtPICSFilter :
virtual void ExamineContract(avtContract_p);
virtual bool CheckOnDemandViability(void);
void AdvectParticle(avtStreamline *sl, int maxSteps=-1);
void IntegrateDomain(avtStreamline *sl,
void AdvectParticle(avtIntegralCurve *ic, int maxSteps=-1);
void IntegrateDomain(avtIntegralCurve *ic,
vtkDataSet *ds,
double *extents,
int maxSteps=-1);
......@@ -182,29 +188,29 @@ class AVTFILTERS_API avtPICSFilter :
int GetNextCurveID(){ int id = MaxID; MaxID++; return id;}
void CreateIntegralCurvesFromSeeds(std::vector<avtVector> &pts,
std::vector<avtStreamline *> &streamlines,
std::vector<avtIntegralCurve *> &ics,
std::vector<std::vector<int> > &ids);
void GetIntegralCurvesFromInitialSeeds(std::vector<avtStreamline *> &sls);
void GetIntegralCurvesFromInitialSeeds(std::vector<avtIntegralCurve *> &ics);
void AddSeedpoints(std::vector<avtVector> &pts,
std::vector<std::vector<int> > &ids);
void DeleteIntegralCurves(std::vector<int> &slIDs);
virtual void CreateIntegralCurveOutput(vector<avtStreamline *> &streamlines)
void DeleteIntegralCurves(std::vector<int> &icIDs);
virtual void CreateIntegralCurveOutput(vector<avtIntegralCurve *> &ics)
= 0;
void GetTerminatedIntegralCurves(vector<avtStreamline *> &sls);
void GetTerminatedIntegralCurves(vector<avtIntegralCurve *> &ics);
// Helper functions.
bool PointInDomain(avtVector &pt, DomainType &domain);
int DomainToRank(DomainType &domain);
void ComputeDomainToRankMapping();
bool OwnDomain(DomainType &domain);
void SetDomain(avtStreamline *sl);
void SetDomain(avtIntegralCurve *ic);
void Initialize();
void ComputeRankList(const std::vector<int> &domList,
std::vector<int> &ranks,
std::vector<int> &doms );
vtkVisItCellLocator *SetupLocator(const DomainType &, vtkDataSet *);
friend class avtSLAlgorithm;
friend class avtICAlgorithm;
};
......
......@@ -37,17 +37,17 @@
*****************************************************************************/
// ************************************************************************* //
// avtParDomSLAlgorithm.h //
// avtParDomICAlgorithm.h //
// ************************************************************************* //
#ifndef AVT_PAR_DOM_SL_ALGORITHM_H
#define AVT_PAR_DOM_SL_ALGORITHM_H
#ifndef AVT_PAR_DOM_IC_ALGORITHM_H
#define AVT_PAR_DOM_IC_ALGORITHM_H
#ifdef PARALLEL
#include "avtParSLAlgorithm.h"
#include "avtParICAlgorithm.h"
// ****************************************************************************
// Class: avtParDomSLAlgorithm
// Class: avtParDomICAlgorithm
//
// Purpose:
// A streamline algorithm that parallelizes over domains.
......@@ -85,16 +85,20 @@
// particle advection, as opposed to streamlines. Also change reference
// from avtStreamlineFilter to avtPICSFilter.
//
// Hank Childs, Sun Jun 6 14:54:08 CDT 2010
// Rename class "IC" from "SL", to reflect the emphasis on integral curves,
// as opposed to streamlines.
//
// ****************************************************************************
class avtParDomSLAlgorithm : public avtParSLAlgorithm
class avtParDomICAlgorithm : public avtParICAlgorithm
{
public:
avtParDomSLAlgorithm(avtPICSFilter *slFilter, int maxCount);
virtual ~avtParDomSLAlgorithm();
avtParDomICAlgorithm(avtPICSFilter *slFilter, int maxCount);
virtual ~avtParDomICAlgorithm();
virtual void Initialize(std::vector<avtStreamline *> &);
virtual void AddIntegralCurves(std::vector<avtStreamline*> &sls);
virtual void Initialize(std::vector<avtIntegralCurve *> &);
virtual void AddIntegralCurves(std::vector<avtIntegralCurve*> &sls);
virtual void ResetIntegralCurvesForContinueExecute();
virtual const char* AlgoName() const {return "ParallelStaticDomains";}
......@@ -102,11 +106,11 @@ class avtParDomSLAlgorithm : public avtParSLAlgorithm
virtual void RunAlgorithm();
virtual void PreRunAlgorithm();
void ExchangeTermination();
void HandleOOBSL(avtStreamline *s);
void HandleOOBIC(avtIntegralCurve *s);
int numSLChange, totalNumIntegralCurves;
int numICChange, totalNumIntegralCurves;
std::list<avtStreamline *> activeSLs;
std::list<avtIntegralCurve *> activeICs;
int maxCnt;
};
......
......@@ -37,17 +37,17 @@
*****************************************************************************/
// ************************************************************************* //
// avtParSLAlgorithm.h //
// avtParICAlgorithm.h //
// ************************************************************************* //
#ifndef AVT_PAR_SL_ALGORITHM_H
#define AVT_PAR_SL_ALGORITHM_H
#ifndef AVT_PAR_IC_ALGORITHM_H
#define AVT_PAR_IC_ALGORITHM_H
#ifdef PARALLEL
#include "avtSLAlgorithm.h"
#include "avtICAlgorithm.h"
// ****************************************************************************
// Class: avtParSLAlgorithm
// Class: avtParICAlgorithm
//
// Purpose:
// Abstract base class for parallel streamline algorithms.
......@@ -58,7 +58,7 @@
// Modifications:
//
// Dave Pugmire, Thu Feb 12 08:43:01 EST 2009
// Removed ComputeStatistics. (Moved to avtSLAlgorithm)
// Removed ComputeStatistics. (Moved to avtICAlgorithm)
//
// Dave Pugmire, Tue Mar 17 12:02:10 EDT 2009
// Create a new RecvSLs method that doesn't check for domain inclusion.
......@@ -79,15 +79,19 @@
// Hank Childs, Sun Jun 6 12:25:31 CDT 2010
// Change reference from avtStreamlineFilter to avtPICSFilter.
//
// Hank Childs, Sun Jun 6 14:54:08 CDT 2010
// Rename class "IC" from "SL", to reflect the emphasis on integral curves,
// as opposed to streamlines.
//
// ****************************************************************************
class avtParSLAlgorithm : public avtSLAlgorithm
class avtParICAlgorithm : public avtICAlgorithm
{
public:
avtParSLAlgorithm(avtPICSFilter *slFilter);
virtual ~avtParSLAlgorithm();
avtParICAlgorithm(avtPICSFilter *icFilter);
virtual ~avtParICAlgorithm();
virtual void Initialize(std::vector<avtStreamline *> &,
virtual void Initialize(std::vector<avtIntegralCurve *> &,
int, int);
virtual void PostExecute();
......@@ -96,30 +100,30 @@ class avtParSLAlgorithm : public avtSLAlgorithm
void InitRequests();
void CheckPendingSendRequests();
void CleanupAsynchronous();
void ExchangeSLSteps();
void ExchangeICSteps();
void PostRecvStatusReq(int idx);
void PostRecvSLReq(int idx);
void PostRecvICReq(int idx);
void SendMsg(int dest, std::vector<int> &msg);
void SendAllMsg(std::vector<int> &msg);
void RecvMsgs(std::vector<std::vector<int> > &msgs);
void SendSLs(int dst,
std::vector<avtStreamline*> &);
bool DoSendSLs(int dst,
std::vector<avtStreamline*> &);
int RecvSLs(std::list<avtStreamline*> &);
int RecvSLs(std::list<avtStreamline*> &,
void SendICs(int dst,
std::vector<avtIntegralCurve*> &);
bool DoSendICs(int dst,
std::vector<avtIntegralCurve*> &);
int RecvICs(std::list<avtIntegralCurve*> &);
int RecvICs(std::list<avtIntegralCurve*> &,
int &earlyTerminations);
bool ExchangeSLs(std::list<avtStreamline *> &,
std::vector<std::vector<avtStreamline *> >&,
bool ExchangeICs(std::list<avtIntegralCurve *> &,
std::vector<std::vector<avtIntegralCurve *> >&,
int &earlyTerminations );
void MergeTerminatedSLSequences();
void MergeTerminatedICSequences();
int rank, nProcs;
std::list<avtStreamline *> communicatedSLs;
std::map<MPI_Request, unsigned char*> sendSLBufferMap, recvSLBufferMap;
std::list<avtIntegralCurve *> communicatedICs;
std::map<MPI_Request, unsigned char*> sendICBufferMap, recvICBufferMap;
std::map<MPI_Request, int *> sendIntBufferMap, recvIntBufferMap;
std::vector<MPI_Request> statusRecvRequests, slRecvRequests;
std::vector<MPI_Request> statusRecvRequests, icRecvRequests;
virtual void CompileTimingStatistics();
virtual void CompileCounterStatistics();
......@@ -128,13 +132,13 @@ class avtParSLAlgorithm : public avtSLAlgorithm
virtual void ReportCounters(ostream &os, bool totals);
//Timers.
SLStatistics CommTime;
ICStatistics CommTime;
//Counters.
SLStatistics MsgCnt, SLCommCnt, BytesCnt;
ICStatistics MsgCnt, ICCommCnt, BytesCnt;
private:
static int STATUS_TAG, STREAMLINE_TAG;
int statusMsgSz, slMsgSz, numAsyncRecvs, msgID;
int statusMsgSz, icMsgSz, numAsyncRecvs, msgID;
};
#endif
......
......@@ -37,19 +37,19 @@
*****************************************************************************/
// ************************************************************************* //
// avtSerialSLAlgorithm.C //
// avtSerialICAlgorithm.C //
// ************************************************************************* //
#include "avtSerialSLAlgorithm.h"
#include "avtSerialICAlgorithm.h"
#include <TimingsManager.h>
using namespace std;
// ****************************************************************************
// Method: avtSerialSLAlgorithm::avtSerialSLAlgorithm
// Method: avtSerialICAlgorithm::avtSerialICAlgorithm
//
// Purpose:
// avtSerialSLAlgorithm constructor.
// avtSerialICAlgorithm constructor.
//
// Programmer: Dave Pugmire
// Creation: January 27, 2009
......@@ -61,28 +61,28 @@ using namespace std;
//
// ****************************************************************************
avtSerialSLAlgorithm::avtSerialSLAlgorithm( avtPICSFilter *slFilter )
: avtSLAlgorithm(slFilter)
avtSerialICAlgorithm::avtSerialICAlgorithm( avtPICSFilter *picsFilter )
: avtICAlgorithm(picsFilter)
{
}
// ****************************************************************************
// Method: avtSerialSLAlgorithm::~avtSerialSLAlgorithm
// Method: avtSerialICAlgorithm::~avtSerialICAlgorithm