Mbox.h File Reference

Mbox* classes perform inter-actor messaging. Mbox is a lockfree multi producer, single consumer queue. More...

#include "Message.h"
#include "Topology.h"

Include dependency graph for Mbox.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	Mbox
	create mailbox More...
class	MboxProducer
	mailbox producer More...
class	Mboxes
	collection of producers More...
struct	Mboxes::location_s
	address and MboxProducer for an actor More...

Macros
#define	REUSEMESSAGES
#define	GETMSG(X, Y, Z)

Detailed Description

Mbox* classes perform inter-actor messaging. Mbox is a lockfree multi producer, single consumer queue.

Author

Mark Travis mtrav.nosp@m.is15.nosp@m.432+s.nosp@m.rc@g.nosp@m.mail..nosp@m.com

Date

Tue Dec 17 13:32:29 2013

Definition in file Mbox.h.

Macro Definition Documentation

#define GETMSG	(		X,
			Y,
			Z
	)

Value:

X=Y->receive(Z);                                                    \
    if (X != NULL && X->messageStruct.topic==TOPIC_SERIALIZED)          \
    {                                                                   \
     SerializedMessage serobj(((class MessageSerialized *)X)->data);    \
     switch (serobj.getpayloadtype())                                   \
     {                                                                  \
case PAYLOADMESSAGE:                                                    \
{                                                                       \
 reuseMessage=Message();                                                \
 reuseMessage.unpack(serobj);                                           \
 if (serobj.data->size() != serobj.pos)                                 \
 {                                                                      \
  fprintf(logfile, "unpack %i size %lu pos %lu\n", serobj.getpayloadtype(), serobj.data->size(), serobj.pos); \
  }                                                                     \
 X=&reuseMessage;                                                       \
 }                                                                      \
break;                                                                  \
case PAYLOADSOCKET:                                                     \
{                                                                       \
 reuseMessageSocket=MessageSocket();                                    \
 reuseMessageSocket.unpack(serobj);                                     \
 if (serobj.data->size() != serobj.pos)                                 \
 {                                                                      \
  fprintf(logfile, "unpack %i size %lu pos %lu\n", serobj.getpayloadtype(), serobj.data->size(), serobj.pos); \
  }                                                                     \
 X=&reuseMessageSocket;                                                 \
 }                                                                      \
break;                                                                  \
case PAYLOADUSERSCHEMA:                                                 \
{                                                                       \
 reuseMessageUserSchema=MessageUserSchema();                            \
 reuseMessageUserSchema.unpack(serobj);                                 \
 if (serobj.data->size() != serobj.pos)                                 \
 {                                                                      \
  fprintf(logfile, "unpack %i size %lu pos %lu\n", serobj.getpayloadtype(), serobj.data->size(), serobj.pos); \
  }                                                                     \
 X=&reuseMessageUserSchema;                                             \
 }                                                                      \
break;                                                                  \
case PAYLOADDEADLOCK:                                                   \
{                                                                       \
 reuseMessageDeadlock=MessageDeadlock();                                \
 reuseMessageDeadlock.unpack(serobj);                                   \
 if (serobj.data->size() != serobj.pos)                                 \
 {                                                                      \
  fprintf(logfile, "unpack %i size %lu pos %lu\n", serobj.getpayloadtype(), serobj.data->size(), serobj.pos); \
  }                                                                     \
 X=&reuseMessageDeadlock;                                               \
 }                                                                      \
break;                                                                  \
case PAYLOADSUBTRANSACTION:                                             \
{                                                                       \
 reuseMessageSubtransactionCmd=MessageSubtransactionCmd();              \
 reuseMessageSubtransactionCmd.unpack(serobj);                          \
 if (serobj.data->size() != serobj.pos)                                 \
 {                                                                      \
  fprintf(logfile, "unpack %i size %lu pos %lu\n", serobj.getpayloadtype(), serobj.data->size(), serobj.pos); \
  }                                                                     \
 X=&reuseMessageSubtransactionCmd;                                      \
 }                                                                      \
break;                                                                  \
case PAYLOADCOMMITROLLBACK:                                             \
{                                                                       \
 reuseMessageCommitRollback=MessageCommitRollback();                    \
 reuseMessageCommitRollback.unpack(serobj);                             \
 if (serobj.data->size() != serobj.pos)                                 \
 {                                                                      \
  fprintf(logfile, "unpack %i size %lu pos %lu\n", serobj.getpayloadtype(), serobj.data->size(), serobj.pos); \
  }                                                                     \
 X=&reuseMessageCommitRollback;                                         \
 }                                                                      \
break;                                                                  \
case PAYLOADDISPATCH:                                                   \
{                                                                       \
 reuseMessageDispatch=MessageDispatch();                                \
 reuseMessageDispatch.unpack(serobj);                                   \
 if (serobj.data->size() != serobj.pos)                                 \
 {                                                                      \
  fprintf(logfile, "unpack %i size %lu pos %lu\n", serobj.getpayloadtype(), serobj.data->size(), serobj.pos); \
  }                                                                     \
 X=&reuseMessageDispatch;                                               \
 }                                                                      \
break;                                                                  \
case PAYLOADACKDISPATCH:                                                \
{                                                                       \
 reuseMessageAckDispatch=MessageAckDispatch();                          \
 reuseMessageAckDispatch.unpack(serobj);                                \
 if (serobj.data->size() != serobj.pos)                                 \
 {                                                                      \
  fprintf(logfile, "unpack %i size %lu pos %lu\n", serobj.getpayloadtype(), serobj.data->size(), serobj.pos); \
  }                                                                     \
 X=&reuseMessageAckDispatch;                                            \
 }                                                                      \
break;                                                                  \
case PAYLOADAPPLY:                                                      \
{                                                                       \
 reuseMessageApply=MessageApply();                                      \
 reuseMessageApply.unpack(serobj);                                      \
 if (serobj.data->size() != serobj.pos)                                 \
 {                                                                      \
  fprintf(logfile, "unpack %i size %lu pos %lu\n", serobj.getpayloadtype(), serobj.data->size(), serobj.pos); \
  }                                                                     \
 X=&reuseMessageApply;                                                  \
 }                                                                      \
break;                                                                  \
case PAYLOADACKAPPLY:                                                   \
{                                                                       \
 reuseMessageAckApply=MessageAckApply();                                \
 reuseMessageAckApply.unpack(serobj);                                   \
 if (serobj.data->size() != serobj.pos)                                 \
 {                                                                      \
  fprintf(logfile, "unpack %i size %lu pos %lu\n", serobj.getpayloadtype(), serobj.data->size(), serobj.pos); \
  }                                                                     \
 X=&reuseMessageAckApply;                                               \
 }                                                                      \
break;                                                                  \
default:                                                                \
printf("%s %i anomaly %i\n", __FILE__, __LINE__, serobj.getpayloadtype()); \
}                                                                       \
     delete serobj.data;                                                \
     }

Definition at line 277 of file Mbox.h.

Referenced by DeadlockMgr::DeadlockMgr(), Engine::Engine(), TransactionAgent::TransactionAgent(), and UserSchemaMgr::UserSchemaMgr().

#define REUSEMESSAGES

Value:

class Message reuseMessage;                   \
    class MessageSocket reuseMessageSocket;                         \
    class MessageUserSchema reuseMessageUserSchema;                 \
    class MessageDeadlock reuseMessageDeadlock;                     \
    class MessageSubtransactionCmd reuseMessageSubtransactionCmd;   \
    class MessageCommitRollback reuseMessageCommitRollback;         \
    class MessageDispatch reuseMessageDispatch;                     \
    class MessageAckDispatch reuseMessageAckDispatch;               \
    class MessageApply reuseMessageApply;                           \
    class MessageAckApply reuseMessageAckApply;

Definition at line 265 of file Mbox.h.