---
name: "sc_MessageGrp"
section: "3"
platform: "linux"
package: "libsc-doc"
version: "2.3.1-22"
release: "Debian 12 (Bookworm)"
platforms: ["linux"]
url: "https://new.carta.tech/sc_MessageGrp"
---

# sc\_MessageGrp(3)

The MessageGrp abstract class provides a mechanism for moving data and objects between nodes in a parallel machine.

## NAME

sc::MessageGrp - The **MessageGrp** abstract class provides a mechanism for moving data and objects between nodes in a parallel machine.

## SYNOPSIS

`#include <message.h>`

Inherits **sc::DescribedClass**.

Inherited by **sc::MPIMessageGrp**, **sc::ProcMessageGrp**, and **sc::intMessageGrp**.

### Public Member Functions

**MessageGrp** (const **Ref**\< **KeyVal** \> &)\
 int **n** ()\
 Returns the number of processors.  int **me** ()\
 Returns my processor number. In the range \[0,**n()**).  virtual **Ref**\< **MessageGrp** \> **clone** (void)=0\
 Returns a copy of this **MessageGrp** specialization that provides an independent communication context.  virtual void **send** (int target, const double \*data, int ndata)\
 Send messages sequentially to the target processor.  virtual void **send** (int target, const unsigned int \*data, int ndata)\
 virtual void **send** (int target, const int \*data, int ndata)\
 virtual void **send** (int target, const char \*data, int nbyte)\
 virtual void **send** (int target, const unsigned char \*data, int nbyte)\
 virtual void **send** (int target, const signed char \*data, int nbyte)\
 virtual void **send** (int target, const short \*data, int ndata)\
 virtual void **send** (int target, const long \*data, int ndata)\
 virtual void **send** (int target, const float \*data, int ndata)\
 void **send** (int target, double data)\
 void **send** (int target, int data)\
 virtual void **raw\_send** (int target, const void \*data, int nbyte)=0\
 virtual void **sendt** (int target, int type, const double \*data, int ndata)\
 Send typed messages to the target processor.  virtual void **sendt** (int target, int type, const unsigned int \*data, int ndata)\
 virtual void **sendt** (int target, int type, const int \*data, int ndata)\
 virtual void **sendt** (int target, int type, const char \*data, int nbyte)\
 virtual void **sendt** (int target, int type, const unsigned char \*data, int nbyte)\
 virtual void **sendt** (int target, int type, const signed char \*data, int nbyte)\
 virtual void **sendt** (int target, int type, const short \*data, int ndata)\
 virtual void **sendt** (int target, int type, const long \*data, int ndata)\
 virtual void **sendt** (int target, int type, const float \*data, int ndata)\
 void **sendt** (int target, int type, double data)\
 void **sendt** (int target, int type, int data)\
 virtual void **raw\_sendt** (int target, int type, const void \*data, int nbyte)=0\
 virtual void **recv** (int sender, double \*data, int ndata)\
 Receive messages sent sequentually from the sender.  virtual void **recv** (int sender, unsigned int \*data, int ndata)\
 virtual void **recv** (int sender, int \*data, int ndata)\
 virtual void **recv** (int sender, char \*data, int nbyte)\
 virtual void **recv** (int sender, unsigned char \*data, int nbyte)\
 virtual void **recv** (int sender, signed char \*data, int nbyte)\
 virtual void **recv** (int sender, short \*data, int ndata)\
 virtual void **recv** (int sender, long \*data, int ndata)\
 virtual void **recv** (int sender, float \*data, int ndata)\
 void **recv** (int sender, double &data)\
 void **recv** (int sender, int &data)\
 virtual void **raw\_recv** (int sender, void \*data, int nbyte)=0\
 virtual void **recvt** (int type, double \*data, int ndata)\
 Receive messages sent by type.  virtual void **recvt** (int type, unsigned int \*data, int ndata)\
 virtual void **recvt** (int type, int \*data, int ndata)\
 virtual void **recvt** (int type, char \*data, int nbyte)\
 virtual void **recvt** (int type, unsigned char \*data, int nbyte)\
 virtual void **recvt** (int type, signed char \*data, int nbyte)\
 virtual void **recvt** (int type, short \*data, int ndata)\
 virtual void **recvt** (int type, long \*data, int ndata)\
 virtual void **recvt** (int type, float \*data, int ndata)\
 void **recvt** (int type, double &data)\
 void **recvt** (int type, int &data)\
 virtual void **raw\_recvt** (int type, void \*data, int nbyte)=0\
 virtual int **probet** (int type)=0\
 Ask if a given typed message has been received.  virtual void **bcast** (double \*data, int ndata, int from=0)\
 Do broadcasts of various types of data.  virtual void **bcast** (unsigned int \*data, int ndata, int from=0)\
 virtual void **bcast** (int \*data, int ndata, int from=0)\
 virtual void **bcast** (char \*data, int nbyte, int from=0)\
 virtual void **bcast** (unsigned char \*data, int nbyte, int from=0)\
 virtual void **bcast** (signed char \*data, int nbyte, int from=0)\
 virtual void **bcast** (short \*data, int ndata, int from=0)\
 virtual void **bcast** (long \*data, int ndata, int from=0)\
 virtual void **bcast** (float \*data, int ndata, int from=0)\
 virtual void **raw\_bcast** (void \*data, int nbyte, int from=0)\
 void **bcast** (double &data, int from=0)\
 void **bcast** (int &data, int from=0)\
 virtual void **raw\_collect** (const void \*part, const int \*lengths, void \*whole, int bytes\_per\_datum=1)\
 Collect data distributed on the nodes to a big array replicated on each node.  void **collect** (const double \*part, const int \*lengths, double \*whole)\
 virtual void **sum** (double \*data, int **n**, double \*=0, int target=-1)\
 Global sum reduction.  virtual void **sum** (unsigned int \*data, int **n**, unsigned int \*=0, int target=-1)\
 virtual void **sum** (int \*data, int **n**, int \*=0, int target=-1)\
 virtual void **sum** (char \*data, int **n**, char \*=0, int target=-1)\
 virtual void **sum** (unsigned char \*data, int **n**, unsigned char \*=0, int target=-1)\
 virtual void **sum** (signed char \*data, int **n**, signed char \*=0, int target=-1)\
 void **sum** (double &data)\
 void **sum** (int &data)\
 virtual void **max** (double \*data, int **n**, double \*=0, int target=-1)\
 Global maximization.  virtual void **max** (int \*data, int **n**, int \*=0, int target=-1)\
 virtual void **max** (unsigned int \*data, int **n**, unsigned int \*=0, int target=-1)\
 virtual void **max** (char \*data, int **n**, char \*=0, int target=-1)\
 virtual void **max** (unsigned char \*data, int **n**, unsigned char \*=0, int target=-1)\
 virtual void **max** (signed char \*data, int **n**, signed char \*=0, int target=-1)\
 void **max** (double &data)\
 void **max** (int &data)\
 virtual void **min** (double \*data, int **n**, double \*=0, int target=-1)\
 Global minimization.  virtual void **min** (int \*data, int **n**, int \*=0, int target=-1)\
 virtual void **min** (unsigned int \*data, int **n**, unsigned int \*=0, int target=-1)\
 virtual void **min** (char \*data, int **n**, char \*=0, int target=-1)\
 virtual void **min** (unsigned char \*data, int **n**, unsigned char \*=0, int target=-1)\
 virtual void **min** (signed char \*data, int **n**, signed char \*=0, int target=-1)\
 void **min** (double &data)\
 void **min** (int &data)\
 virtual void **reduce** (double \*, int **n**, **GrpReduce**\< double \> &, double \*scratch=0, int target=-1)\
 Global generic reduction.  virtual void **reduce** (int \*, int **n**, **GrpReduce**\< int \> &, int \*scratch=0, int target=-1)\
 virtual void **reduce** (unsigned int \*, int **n**, **GrpReduce**\< unsigned int \> &, unsigned int \*scratch=0, int target=-1)\
 virtual void **reduce** (char \*, int **n**, **GrpReduce**\< char \> &, char \*scratch=0, int target=-1)\
 virtual void **reduce** (unsigned char \*, int **n**, **GrpReduce**\< unsigned char \> &, unsigned char \*scratch=0, int target=-1)\
 virtual void **reduce** (signed char \*, int **n**, **GrpReduce**\< signed char \> &, signed char \*scratch=0, int target=-1)\
 virtual void **reduce** (short \*, int **n**, **GrpReduce**\< short \> &, short \*scratch=0, int target=-1)\
 virtual void **reduce** (float \*, int **n**, **GrpReduce**\< float \> &, float \*scratch=0, int target=-1)\
 virtual void **reduce** (long \*, int **n**, **GrpReduce**\< long \> &, long \*scratch=0, int target=-1)\
 void **reduce** (double &data, **GrpReduce**\< double \> &r)\
 void **reduce** (int &data, **GrpReduce**\< int \> &r)\
 virtual void **sync** ()\
 Synchronize all of the processors.  **Ref**\< **MachineTopology** \> **topology** ()\
 Return the **MachineTopology** object.  int **classdesc\_to\_index** (const **ClassDesc** \*)\
 Each message group maintains an association of **ClassDesc** with a global index so **SavableState** information can be sent between nodes without needing to send the classname and look up the **ClassDesc** with each transfer.  const **ClassDesc** \* **index\_to\_classdesc** (int)\
 int **nclass** () const\

### Static Public Member Functions

static void **set\_default\_messagegrp** (const **Ref**\< **MessageGrp** \> &)\
 The default message group contains the primary message group to be used by an application.  static **MessageGrp** \* **get\_default\_messagegrp** ()\
 Returns the default message group.  static **MessageGrp** \* **initial\_messagegrp** (int &argc, char \*\*&argv)\
 Create a message group.

### Protected Member Functions

void **initialize** (int **me**, int **n**)\
 The classdesc\_to\_index\_ and index\_to\_classdesc\_ arrays cannot be initialized by the **MessageGrp** CTOR, because the **MessageGrp** specialization has not yet been initialized and communication is not available.

### Protected Attributes

**Ref**\< **MachineTopology** \> **topology\_**\
 int **debug\_**\

## Detailed Description

The **MessageGrp** abstract class provides a mechanism for moving data and objects between nodes in a parallel machine.

## Member Function Documentation

### virtual void sc::MessageGrp::bcast (double \* data, int ndata, int from = `0`)` [virtual]`

Do broadcasts of various types of data. Similar members exist for each of the basic types.

### int sc::MessageGrp::classdesc\_to\_index (const ClassDesc \*)

Each message group maintains an association of **ClassDesc** with a global index so **SavableState** information can be sent between nodes without needing to send the classname and look up the **ClassDesc** with each transfer. These routines return information about that mapping.

### virtual Ref\< MessageGrp \> sc::MessageGrp::clone (void)` [pure virtual]`

Returns a copy of this **MessageGrp** specialization that provides an independent communication context.

Implemented in **sc::ProcMessageGrp**, **sc::MPIMessageGrp**, and **sc::ShmMessageGrp**.

### static MessageGrp \* sc::MessageGrp::initial\_messagegrp (int & argc, char \*\*& argv)` [static]`

Create a message group. This routine looks for a -messagegrp argument, then the environmental variable MESSAGEGRP to decide which specialization of **MessageGrp** would be appropriate. The argument to -messagegrp should be either string for a **ParsedKeyVal** constructor or a classname. If this returns null, it is up to the programmer to create a **MessageGrp**.

### void sc::MessageGrp::initialize (int me, int n)` [protected]`

The classdesc\_to\_index\_ and index\_to\_classdesc\_ arrays cannot be initialized by the **MessageGrp** CTOR, because the **MessageGrp** specialization has not yet been initialized and communication is not available. CTOR's of specializations of **MessageGrp** must call the initialize member in their body to complete the initialization process.

### virtual void sc::MessageGrp::max (double \* data, int n, double \* = `0`, int target = `-1`)` [virtual]`

Global maximization. Similar members exist for each of the basic types.

### virtual void sc::MessageGrp::min (double \* data, int n, double \* = `0`, int target = `-1`)` [virtual]`

Global minimization. Similar members exist for each of the basic types.

### virtual int sc::MessageGrp::probet (int type)` [pure virtual]`

Ask if a given typed message has been received.

Implemented in **sc::ProcMessageGrp**, **sc::MPIMessageGrp**, and **sc::intMessageGrp**.

### virtual void sc::MessageGrp::recv (int sender, double \* data, int ndata)` [virtual]`

Receive messages sent sequentually from the sender. Similar members exist for each of the basic types.

### virtual void sc::MessageGrp::recvt (int type, double \* data, int ndata)` [virtual]`

Receive messages sent by type. Similar members exist for each of the basic types.

### virtual void sc::MessageGrp::reduce (double \*, int n, GrpReduce\< double \> &, double \* scratch = `0`, int target = `-1`)` [virtual]`

Global generic reduction. Similar members exist for each of the basic types.

Reimplemented in **sc::MPIMessageGrp**.

### virtual void sc::MessageGrp::send (int target, const double \* data, int ndata)` [virtual]`

Send messages sequentially to the target processor. Similar members exist for each of the basic types.

### virtual void sc::MessageGrp::sendt (int target, int type, const double \* data, int ndata)` [virtual]`

Send typed messages to the target processor. Similar members exist for each of the basic types.

### virtual void sc::MessageGrp::sum (double \* data, int n, double \* = `0`, int target = `-1`)` [virtual]`

Global sum reduction. Similar members exist for each of the basic types.

Reimplemented in **sc::MPIMessageGrp**.

### virtual void sc::MessageGrp::sync ()` [virtual]`

Synchronize all of the processors.

Reimplemented in **sc::ProcMessageGrp**, **sc::MPIMessageGrp**, and **sc::ShmMessageGrp**.

## Author

Generated automatically by Doxygen for MPQC from the source code.