gs.hpp

Go to the documentation of this file.

#ifndef GS_HPP
#define GS_HPP
 
#include "moab/MOABConfig.h"
#include "moab/TupleList.hpp"
#include "moab/Types.hpp"
 
#ifdef MOAB_HAVE_MPI
#include "moab_mpi.h"
#endif
 
namespace moab
{
 
class gs_data
{
 public:
#ifdef MOAB_HAVE_MPI
 class nonlocal_info
 {
 public:
 uint _np; /* number of processors to communicate with */
 uint* _target; /* int target[np]: array of processor ids to comm w/ */
 uint* _nshared; /* nshared[i] = number of points shared w/ target[i] */
 uint* _sh_ind; /* list of shared point indices */
 slong* _slabels; /* list of signed long labels (not including gid) */
 Ulong* _ulabels; /* list of unsigned long labels */
 MPI_Request* _reqs; /* pre-allocated for MPI calls */
 realType* _buf; /* pre-allocated buffer to receive data */
 uint _maxv; /* maximum vector size */
 
 /**Constructor for nonlocal_info; takes all arguments and initializes
 * nonlocal_info
 *
 * param np number of processors to communicate with
 * param count number of partner processors
 * param nlabels number of signed long labels (not including gid)
 * param nulabels number of unsigned long labels
 * param maxv maximum vector size
 */
 nonlocal_info( uint tmp_np, uint count, uint nlabels, uint nulabels, uint tmp_maxv )
 {
 this->initialize( tmp_np, count, nlabels, nulabels, tmp_maxv );
 }
 
 /**Initializes nonlocal_info; see constructor for parameter documentation
 */
 void initialize( uint np, uint count, uint nlabels, uint nulabels, uint maxv );
 
 ~nonlocal_info()
 {
 nlinfo_free();
 };
 
 void nonlocal( realType* u, int op, MPI_Comm comm );
 void nonlocal_vec( realType* u, uint n, int op, MPI_Comm comm );
 void nonlocal_many( realType** u, uint n, int op, MPI_Comm comm );
 void nlinfo_free();
 };
 
 public:
 /*---------------------------------------------------------------------------
 
 Crystal Router
 
 Accomplishes all-to-all communication in log P msgs per proc
 The routine is low-level; the format of the input/output is an
 array of integers, consisting of a sequence of messages with format:
 
 target proc
 source proc
 m
 integer
 integer
 ...
 integer (m integers in total)
 
 Before moab_crystal_router is called, the source of each message should be
 set to this proc id; upon return from moab_crystal_router, the target of each
 message will be this proc id.
 
 Usage:
 
 MPI_Comm comm = ... ;
 moab_crystal_data crystal;
 //moab_crystal_data crystal(comm); //or this to initialize on
 //instantiation
 
 crystal.initialize(comm); // initialize the data structure
 // now crystal.id = this proc
 // and crystal.num = num of procs
 
 // allocate space for at least MAX ints
 buffer_reserve(&crystal->all->buf, MAX*sizeof(uint));
 
 // fill up ((uint*)crystal->all->buf.ptr)[0 ... n-1]
 // and set crystal->all->n
 
 crystal.moab_crystal_router();
 
 // incoming messages available as
 // ((uint*)crystal->all->buf.ptr)[0 ... crystal->all->n-1]
 
 crystal.reset(); // release acquired memory
 
 ---------------------------------------------------------------------------*/
 
 class crystal_data
 {
 public:
 // moab_crystal_data member variables & data
 typedef struct
 {
 uint n;
 moab::TupleList::buffer buf;
 } crystal_buf;
 crystal_buf buffers[3];
 // crystal_buf provides buffer space for communications
 crystal_buf *all, *keep, *send;
 MPI_Comm _comm;
 uint _num, _id;
 
 /**Default constructor (Note: moab_crystal_data must be initialized
 * before use!)
 */
 crystal_data();
 
 /**Constructor takes an MPI_Comm and initializes the moab_data_crystal
 */
 crystal_data( MPI_Comm cm )
 {
 initialize( cm );
 };
 
 ~crystal_data()
 {
 reset();
 };
 
 /**Initializes crystal_data members according to MPI_Comm passed in
 * Note: moab_crystal_data must be initialized before it can be used
 *
 * param comm MPI_Comm detailing where to send messages
 */
 void initialize( MPI_Comm comm );
 
 /**Frees buffers used by moab_crystal_data
 */
 void reset();
 
 /**Communicates messages with other processors; see class description for
 * more info and usage
 */
 void crystal_router();
 
 /**Treats one integer (not long) member of the TupleList as a target proc;
 * Sends out tuples accordingly, using the crystal router.
 * Target proc member overwritten with source proc.
 *
 * param dynamic non-zero if the TupleList should grow to accomodate
 * arrivals
 * param tl the TupleList
 * param pf which tuple member specifies target proc
 */
 ErrorCode gs_transfer( int dynamic, moab::TupleList& tl, unsigned pf );
 
 private:
 // Used by moab_crystal_router: see .cpp for more details
 void partition( uint cutoff, crystal_buf* lo, crystal_buf* hi );
 
 void send_( uint target, int recvn );
 };
#else
 // If mpi is not used, moab_crystal_data cannot be used
 class crystal_data
 {
 };
#endif
 
 sint* local_cm; /* local condense map */
#ifdef MOAB_HAVE_MPI
 nonlocal_info* nlinfo;
 MPI_Comm _comm;
#endif
 
 /**Constructor for moab_gs_data: takes all arguments and initializes
 * moab_gs_data. If needs_reset is false after calling constructor,
 * initialization has failed.
 *
 * param n number of tuples in tuple list
 * param label pointer to signed labels
 * param ulabel pointer to unsigned labels
 * param maxv max vector size
 * param nlabels number of signed long labels (not including gid)
 * param nulabels number of unsigned long labels
 * param crystal moab_crystal_data contains MPI_Comm and is used for
 * message passing
 */
 gs_data( uint n,
 const long* label,
 const Ulong* ulabel,
 uint maxv,
 const unsigned int nlabels,
 const unsigned int nulabels,
 crystal_data* crystal,
 ErrorCode& Init_Result )
 {
 Init_Result = this->initialize( n, label, ulabel, maxv, nlabels, nulabels, crystal );
 };
 
 /**Default constructor (Note: moab_gs_data must be initialized
 * before use!)
 */
 gs_data(){};
 
 ~gs_data()
 {
 reset();
 }
 
 /**Sets up the moab_gs_data; see constructor for parameter documentation
 */
 ErrorCode initialize( uint n,
 const long* label,
 const Ulong* ulabel,
 uint maxv,
 const unsigned int nlabels,
 const unsigned int nulabels,
 crystal_data* crystal );
 
 void reset();
 
 void gs_data_op( realType* u, int op );
 void gs_data_op_vec( realType* u, uint n, int op );
 void gs_data_op_many( realType** u, uint n, int op );
 
#define GS_OP_ADD 1
#define GS_OP_MUL 2
#define GS_OP_MIN 3
#define GS_OP_MAX 4
#define GS_OP_BPR 5
};
 
} // namespace moab
#endif