MOAB: Mesh Oriented datABase  (version 5.2.1)
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 <math.h>
#include <cstdlib>
#include <assert.h>
+ Include dependency graph for ParallelComm.cpp:

Go to the source code of this file.

Classes

struct  moab::set_tuple
struct  moab::ProcList

Namespaces

namespace  moab
 

Class representing axis-aligned bounding box.


Defines

#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.
#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"

Define Documentation

#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.

Referenced by moab::ParallelComm::pcomm_tag().

#define ppstat (   a,
  b 
)
Value:
{                              \
        if( pstat & a )            \
        {                          \
            if( num ) str << ", "; \
            str << b;              \
            num++;                 \
        }                          \
    }

Referenced by moab::ParallelComm::print_pstatus().

#define PRINT_DEBUG_ISEND (   A,
  B,
  C,
  D,
 
)    print_debug_isend( ( A ), ( B ), ( C ), ( D ), ( E ) )
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines