ParallelComm.cpp File Reference

#include "moab/Interface.hpp"
#include "moab/ParallelComm.hpp"
#include "moab/WriteUtilIface.hpp"
#include "moab/ReadUtilIface.hpp"
#include "SequenceManager.hpp"
#include "moab/Error.hpp"
#include "EntitySequence.hpp"
#include "MBTagConventions.hpp"
#include "moab/Skinner.hpp"
#include "MBParallelConventions.h"
#include "moab/Core.hpp"
#include "ElementSequence.hpp"
#include "moab/CN.hpp"
#include "moab/RangeMap.hpp"
#include "moab/MeshTopoUtil.hpp"
#include "TagInfo.hpp"
#include "DebugOutput.hpp"
#include "SharedSetData.hpp"
#include "moab/ScdInterface.hpp"
#include "moab/TupleList.hpp"
#include "moab/gs.hpp"
#include <iostream>
#include <sstream>
#include <algorithm>
#include <functional>
#include <numeric>
#include <cmath>
#include <cstdlib>
#include <cassert>

Include dependency graph for ParallelComm.cpp:

Go to the source code of this file.

Classes
struct	moab::set_tuple
struct	moab::ProcList

Namespaces
	moab
	Class representing axis-aligned bounding box.

Macros
#define	PC(n, m)
#define	UPC(n, m)
#define	PRINT_DEBUG_ISEND(A, B, C, D, E)   print_debug_isend( ( A ), ( B ), ( C ), ( D ), ( E ) )
#define	PRINT_DEBUG_IRECV(A, B, C, D, E, F)   print_debug_irecv( ( A ), ( B ), ( C ), ( D ), ( E ), ( F ) )
#define	PRINT_DEBUG_RECD(A)   print_debug_recd( ( A ) )
#define	PRINT_DEBUG_WAITANY(A, B, C)   print_debug_waitany( ( A ), ( B ), ( C ) )
#define	PARALLEL_COMM_TAG_NAME   "__PARALLEL_COMM"
	Tag storing parallel communication objects. More...
#define	ppstat(a, b)

Enumerations
enum	moab::MBMessageTag {   moab::MB_MESG_ANY = MPI_ANY_TAG , moab::MB_MESG_ENTS_ACK , moab::MB_MESG_ENTS_SIZE , moab::MB_MESG_ENTS_LARGE ,   moab::MB_MESG_REMOTEH_ACK , moab::MB_MESG_REMOTEH_SIZE , moab::MB_MESG_REMOTEH_LARGE , moab::MB_MESG_TAGS_ACK ,   moab::MB_MESG_TAGS_SIZE , moab::MB_MESG_TAGS_LARGE }

Functions
template<typename T >
static void	moab::UNPACK (unsigned char *&buff, T *val, size_t count)
template<typename T >
static void	moab::PACK (unsigned char *&buff, const T *val, size_t count)
static void	moab::PACK_INTS (unsigned char *&buff, const int *int_val, size_t num)
static void	moab::PACK_INT (unsigned char *&buff, int int_val)
static void	moab::PACK_DBLS (unsigned char *&buff, const double *dbl_val, size_t num)
static void	moab::PACK_EH (unsigned char *&buff, const EntityHandle *eh_val, size_t num)
static void	moab::PACK_VOID (unsigned char *&buff, const void *val, size_t num)
static void	moab::PACK_BYTES (unsigned char *&buff, const void *val, int num)
static void	moab::PACK_RANGE (unsigned char *&buff, const Range &rng)
static void	moab::UNPACK_INTS (unsigned char *&buff, int *int_val, size_t num)
static void	moab::UNPACK_INT (unsigned char *&buff, int &int_val)
static void	moab::UNPACK_DBLS (unsigned char *&buff, double *dbl_val, size_t num)
static void	moab::UNPACK_DBL (unsigned char *&buff, double &dbl_val)
static void	moab::UNPACK_EH (unsigned char *&buff, EntityHandle *eh_val, size_t num)
static void	moab::UNPACK_VOID (unsigned char *&buff, void *val, size_t num)
static void	moab::UNPACK_TYPE (unsigned char *&buff, EntityType &type)
static void	moab::UNPACK_RANGE (unsigned char *&buff, Range &rng)
static size_t	moab::RANGE_SIZE (const Range &rng)
void	moab::print_buff (unsigned char *ch, int size)
template<class T >
T	moab::LAND (const T &arg1, const T &arg2)
template<class T >
T	moab::LOR (const T &arg1, const T &arg2)
template<class T >
T	moab::LXOR (const T &arg1, const T &arg2)
template<class T >
T	moab::MAX (const T &arg1, const T &arg2)
template<class T >
T	moab::MIN (const T &arg1, const T &arg2)
template<class T >
T	moab::ADD (const T &arg1, const T &arg2)
template<class T >
T	moab::MULT (const T &arg1, const T &arg2)
static size_t	moab::choose_owner_idx (const std::vector< unsigned > &proc_list)
bool	moab::is_sorted_unique (std::vector< unsigned > &v)
static bool	moab::operator< (const ProcList &a, const ProcList &b)

Variables
const int	moab::MAX_BCAST_SIZE = ( 1 << 28 )
std::vector< ParallelComm::Buffer * >	moab::msgs
unsigned int	moab::__PACK_num = 0
unsigned int	moab::__UNPACK_num = 0
unsigned int	moab::__PACK_count = 0
unsigned int	moab::__UNPACK_count = 0
std::string	moab::__PACK_string
std::string	moab::__UNPACK_string
const char *	moab::PARTITIONING_PCOMM_TAG_NAME = "__PRTN_PCOMM"

Macro Definition Documentation

PARALLEL_COMM_TAG_NAME

#define PARALLEL_COMM_TAG_NAME   "__PARALLEL_COMM"

Tag storing parallel communication objects.

This tag stores pointers to ParallelComm communication objects; one of these is allocated for each different communicator used to read mesh. ParallelComm stores partition and interface sets corresponding to its parallel mesh. By default, a parallel read uses the first ParallelComm object on the interface instance; if instantiated with one, ReadParallel adds this object to the interface instance too.

Tag type: opaque Tag size: MAX_SHARING_PROCS*sizeof(ParallelComm*)

Definition at line 311 of file ParallelComm.cpp.

PC

#define PC	(		n,
			m
	)

Definition at line 86 of file ParallelComm.cpp.

ppstat

#define ppstat	(		a,
			b
	)

Value:

    {                              \
        if( pstat & ( a ) )        \
        {                          \
            if( num ) str << ", "; \
            str << ( b );          \
            num++;                 \
        }                          \
    }

PRINT_DEBUG_IRECV

#define PRINT_DEBUG_IRECV	(		A,
			B,
			C,
			D,
			E,
			F
	)		print_debug_irecv( ( A ), ( B ), ( C ), ( D ), ( E ), ( F ) )

Definition at line 246 of file ParallelComm.cpp.

PRINT_DEBUG_ISEND

#define PRINT_DEBUG_ISEND	(		A,
			B,
			C,
			D,
			E
	)		print_debug_isend( ( A ), ( B ), ( C ), ( D ), ( E ) )

Definition at line 245 of file ParallelComm.cpp.

PRINT_DEBUG_RECD

#define PRINT_DEBUG_RECD

(

A

)

print_debug_recd( ( A ) )

Definition at line 247 of file ParallelComm.cpp.

PRINT_DEBUG_WAITANY

#define PRINT_DEBUG_WAITANY	(		A,
			B,
			C
	)		print_debug_waitany( ( A ), ( B ), ( C ) )

Definition at line 248 of file ParallelComm.cpp.

UPC

#define UPC	(		n,
			m
	)

Definition at line 87 of file ParallelComm.cpp.