The world's most popular open source database

MySQL 5.1: SHM_Transporter Class Reference

SHM_Transporter Class Reference

main class for the SHM transporter.

More...

#include <SHM_Transporter.hpp>

Inheritance diagram for SHM_Transporter:

[legend]Collaboration diagram for SHM_Transporter:

[legend]List of all members.


Public Member Functions
	SHM_Transporter (TransporterRegistry &, const char lHostName, const char rHostName, int r_port, bool isMgmConnection, NodeId lNodeId, NodeId rNodeId, NodeId serverNodeId, bool checksum, bool signalId, key_t shmKey, Uint32 shmSize)
virtual	~SHM_Transporter ()
bool	initTransporter ()
Uint32 *	getWritePtr (Uint32 lenBytes, Uint32 prio)
void	updateWritePtr (Uint32 lenBytes, Uint32 prio)
void	getReceivePtr (Uint32 ptr, Uint32 eod)
void	updateReceivePtr (Uint32 *ptr)
Protected Member Functions
void	disconnectImpl ()
virtual bool	connect_server_impl (NDB_SOCKET_TYPE sockfd)
virtual bool	connect_client_impl (NDB_SOCKET_TYPE sockfd)
bool	connect_common (NDB_SOCKET_TYPE sockfd)
bool	ndb_shm_create ()
bool	ndb_shm_get ()
bool	ndb_shm_attach ()
bool	checkConnected ()
void	setupBuffers ()
void	doSend ()
virtual Uint32	get_free_buffer () const
Protected Attributes
int	m_remote_pid
Uint32	m_last_signal
Uint32	m_signal_threshold
Private Member Functions
bool	hasDataToRead () const
void	make_error_info (char info[], int sz)
Private Attributes
bool	_shmSegCreated
bool	_attached
bool	m_connected
key_t	shmKey
volatile Uint32 *	serverStatusFlag
volatile Uint32 *	clientStatusFlag
bool	setupBuffersDone
int	shmId
int	shmSize
char *	shmBuf
SHM_Reader *	reader
SHM_Writer *	writer
Friends
class	TransporterRegistry

Detailed Description

main class for the SHM transporter.

class SHMTransporter

Definition at line 32 of file SHM_Transporter.hpp.

Constructor & Destructor Documentation

SHM_Transporter::SHM_Transporter	(	TransporterRegistry &	,
		const char *	lHostName,
		const char *	rHostName,
		int	r_port,
		bool	isMgmConnection,
		NodeId	lNodeId,
		NodeId	rNodeId,
		NodeId	serverNodeId,
		bool	checksum,
		bool	signalId,
		key_t	shmKey,
		Uint32	shmSize
	)

Definition at line 31 of file SHM_Transporter.cpp.

References _attached, _shmSegCreated, m_signal_threshold, reader, setupBuffersDone, shmBuf, shmId, shmKey, and writer.

00042                                                   :
00043   Transporter(t_reg, tt_SHM_TRANSPORTER,
00044               lHostName, rHostName, r_port, isMgmConnection,
00045               lNodeId, rNodeId, serverNodeId,
00046               0, false, checksum, signalId),
00047   shmKey(_shmKey),
00048   shmSize(_shmSize)
00049 {
00050 #ifndef NDB_WIN32
00051   shmId= 0;
00052 #endif
00053   _shmSegCreated = false;
00054   _attached = false;
00055 
00056   shmBuf = 0;
00057   reader = 0;
00058   writer = 0;
00059   
00060   setupBuffersDone=false;
00061 #ifdef DEBUG_TRANSPORTER
00062   printf("shm key (%d - %d) = %d\n", lNodeId, rNodeId, shmKey);
00063 #endif
00064   m_signal_threshold = 4096;
00065 }

SHM_Transporter::~SHM_Transporter ( ) [virtual]

SHM destructor

Definition at line 67 of file SHM_Transporter.cpp.

References Transporter::doDisconnect().

00067                                  {
00068   doDisconnect();
00069 }

Here is the call graph for this function:

Member Function Documentation

bool SHM_Transporter::checkConnected ( ) [protected]

Check if there are two processes attached to the segment (a connection)

Returns:: - True if the above holds. Otherwise false.

Definition at line 69 of file SHM_Transporter.unix.cpp.

References buf, DBUG_PRINT, errno, make_error_info(), Transporter::remoteNodeId, Transporter::report_error(), shmId, TE_SHM_DISCONNECT, TE_SHM_IPC_PERMANENT, and TE_SHM_IPC_STAT.

Referenced by connect_common(), and TransporterRegistry::performReceive().

00069                                {
00070   struct shmid_ds info;
00071   const int res = shmctl(shmId, IPC_STAT, &info);
00072   if(res == -1){
00073     char buf[128];
00074     int r= snprintf(buf, sizeof(buf),
00075                     "shmctl(%d, IPC_STAT) errno: %d(%s). ", shmId,
00076                     errno, strerror(errno));
00077     make_error_info(buf+r, sizeof(buf)-r);
00078     DBUG_PRINT("error",(buf));
00079     switch (errno)
00080     {
00081     case EACCES:
00082       report_error(TE_SHM_IPC_PERMANENT, buf);
00083       break;
00084     default:
00085       report_error(TE_SHM_IPC_STAT, buf);
00086       break;
00087     }
00088     return false;
00089   }
00090  
00091   if(info.shm_nattch != 2){
00092     char buf[128];
00093     make_error_info(buf, sizeof(buf));
00094     report_error(TE_SHM_DISCONNECT);
00095     DBUG_PRINT("error", ("Already connected to node %d",
00096                 remoteNodeId));
00097     return false;
00098   }
00099   return true;
00100 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool SHM_Transporter::connect_client_impl ( NDB_SOCKET_TYPE sockfd ) [protected, virtual]

Blocking

Attach to shm segment
Check if the segment is setup
Check if the server set it up
If all clear, return.
Parameters:

timeOutMillis - the time to sleep before (ms) trying again.

Returns:
- True if the client managed to hook up with the server, i.e., both agrees that the other one has setup the segment. Otherwise false.

Implements Transporter.

Definition at line 264 of file SHM_Transporter.cpp.

References _attached, _shmSegCreated, buf, connect_common(), DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, SocketInputStream::gets(), m_remote_pid, TransporterRegistry::m_shm_own_pid, Transporter::m_transporter_registry, make_error_info(), NDB_CLOSE_SOCKET(), ndb_shm_attach(), ndb_shm_get(), SocketOutputStream::println(), Transporter::remoteNodeId, Transporter::report_error(), and TE_SHM_UNABLE_TO_ATTACH_SEGMENT.

00265 {
00266   DBUG_ENTER("SHM_Transporter::connect_client_impl");
00267   SocketInputStream s_input(sockfd);
00268   SocketOutputStream s_output(sockfd);
00269   char buf[256];
00270 
00271   // Wait for server to create and attach
00272   DBUG_PRINT("info", ("Wait for server to create and attach"));
00273   if (s_input.gets(buf, 256) == 0) {
00274     NDB_CLOSE_SOCKET(sockfd);
00275     DBUG_PRINT("error", ("Server id %d did not attach",
00276                 remoteNodeId));
00277     DBUG_RETURN(false);
00278   }
00279 
00280   if(sscanf(buf, "shm server 1 ok: %d", &m_remote_pid) != 1)
00281   {
00282     NDB_CLOSE_SOCKET(sockfd);
00283     DBUG_RETURN(false);
00284   }
00285   
00286   // Create
00287   if(!_shmSegCreated){
00288     if (!ndb_shm_get()) {
00289       NDB_CLOSE_SOCKET(sockfd);
00290       DBUG_PRINT("error", ("Failed create of shm seg to node %d",
00291                   remoteNodeId));
00292       DBUG_RETURN(false);
00293     }
00294     _shmSegCreated = true;
00295   }
00296 
00297   // Attach
00298   if(!_attached){
00299     if (!ndb_shm_attach()) {
00300       make_error_info(buf, sizeof(buf));
00301       report_error(TE_SHM_UNABLE_TO_ATTACH_SEGMENT, buf);
00302       NDB_CLOSE_SOCKET(sockfd);
00303       DBUG_PRINT("error", ("Failed attach of shm seg to node %d",
00304                   remoteNodeId));
00305       DBUG_RETURN(false);
00306     }
00307     _attached = true;
00308   }
00309 
00310   // Send ok to server
00311   s_output.println("shm client 1 ok: %d", 
00312                    m_transporter_registry.m_shm_own_pid);
00313   
00314   int r= connect_common(sockfd);
00315   
00316   if (r) {
00317     // Wait for ok from server
00318     DBUG_PRINT("info", ("Wait for ok from server"));
00319     if (s_input.gets(buf, 256) == 0) {
00320       NDB_CLOSE_SOCKET(sockfd);
00321       DBUG_PRINT("error", ("No ok from server node %d",
00322                   remoteNodeId));
00323       DBUG_RETURN(false);
00324     }
00325     // Send ok to server
00326     s_output.println("shm client 2 ok");
00327     DBUG_PRINT("info", ("Successfully connected client to node %d",
00328                 remoteNodeId)); 
00329   }
00330 
00331   NDB_CLOSE_SOCKET(sockfd);
00332   DBUG_RETURN(r);
00333 }

Here is the call graph for this function:

bool SHM_Transporter::connect_common ( NDB_SOCKET_TYPE sockfd ) [protected]

Definition at line 336 of file SHM_Transporter.cpp.

References checkConnected(), clientStatusFlag, DBUG_PRINT, m_last_signal, Transporter::m_timeOutMillis, NdbSleep_MilliSleep(), Transporter::remoteNodeId, serverStatusFlag, setupBuffers(), and setupBuffersDone.

Referenced by connect_client_impl(), and connect_server_impl().

00337 {
00338   if (!checkConnected()) {
00339     return false;
00340   }
00341   
00342   if(!setupBuffersDone) 
00343   {
00344     setupBuffers();
00345     setupBuffersDone=true;
00346   }
00347 
00348   if(setupBuffersDone) 
00349   {
00350     NdbSleep_MilliSleep(m_timeOutMillis);
00351     if(*serverStatusFlag == 1 && *clientStatusFlag == 1)
00352     {
00353       m_last_signal = 0;
00354       return true;
00355     }
00356   }
00357 
00358   DBUG_PRINT("error", ("Failed to set up buffers to node %d",
00359               remoteNodeId));
00360   return false;
00361 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool SHM_Transporter::connect_server_impl ( NDB_SOCKET_TYPE sockfd ) [protected, virtual]

Blocking

Create shm segment
Attach to it
Wait for someone to attach (max wait = timeout), then rerun again until connection established.
Parameters:

timeOutMillis - the time to sleep before (ms) trying again.

Returns:
- True if the server managed to hook up with the client, i.e., both agrees that the other one has setup the segment. Otherwise false.

Implements Transporter.

Definition at line 198 of file SHM_Transporter.cpp.

References _attached, _shmSegCreated, buf, connect_common(), DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, SocketInputStream::gets(), m_remote_pid, TransporterRegistry::m_shm_own_pid, Transporter::m_transporter_registry, make_error_info(), NDB_CLOSE_SOCKET(), ndb_shm_attach(), ndb_shm_create(), SocketOutputStream::println(), Transporter::remoteNodeId, Transporter::report_error(), TE_SHM_UNABLE_TO_ATTACH_SEGMENT, and TE_SHM_UNABLE_TO_CREATE_SEGMENT.

00199 {
00200   DBUG_ENTER("SHM_Transporter::connect_server_impl");
00201   SocketOutputStream s_output(sockfd);
00202   SocketInputStream s_input(sockfd);
00203   char buf[256];
00204 
00205   // Create
00206   if(!_shmSegCreated){
00207     if (!ndb_shm_create()) {
00208       make_error_info(buf, sizeof(buf));
00209       report_error(TE_SHM_UNABLE_TO_CREATE_SEGMENT, buf);
00210       NDB_CLOSE_SOCKET(sockfd);
00211       DBUG_RETURN(false);
00212     }
00213     _shmSegCreated = true;
00214   }
00215 
00216   // Attach
00217   if(!_attached){
00218     if (!ndb_shm_attach()) {
00219       make_error_info(buf, sizeof(buf));
00220       report_error(TE_SHM_UNABLE_TO_ATTACH_SEGMENT, buf);
00221       NDB_CLOSE_SOCKET(sockfd);
00222       DBUG_RETURN(false);
00223     }
00224     _attached = true;
00225   }
00226 
00227   // Send ok to client
00228   s_output.println("shm server 1 ok: %d", 
00229                    m_transporter_registry.m_shm_own_pid);
00230   
00231   // Wait for ok from client
00232   DBUG_PRINT("info", ("Wait for ok from client"));
00233   if (s_input.gets(buf, sizeof(buf)) == 0) 
00234   {
00235     NDB_CLOSE_SOCKET(sockfd);
00236     DBUG_RETURN(false);
00237   }
00238 
00239   if(sscanf(buf, "shm client 1 ok: %d", &m_remote_pid) != 1)
00240   {
00241     NDB_CLOSE_SOCKET(sockfd);
00242     DBUG_RETURN(false);
00243   }
00244 
00245   int r= connect_common(sockfd);
00246 
00247   if (r) {
00248     // Send ok to client
00249     s_output.println("shm server 2 ok");
00250     // Wait for ok from client
00251     if (s_input.gets(buf, 256) == 0) {
00252       NDB_CLOSE_SOCKET(sockfd);
00253       DBUG_RETURN(false);
00254     }
00255     DBUG_PRINT("info", ("Successfully connected server to node %d",
00256                 remoteNodeId)); 
00257   }
00258 
00259   NDB_CLOSE_SOCKET(sockfd);
00260   DBUG_RETURN(r);
00261 }

Here is the call graph for this function:

void SHM_Transporter::disconnectImpl ( ) [protected, virtual]

disconnect a segmnet

deletes the shm buffer associated with a segment
marks the segment for removal

Implements Transporter.

Definition at line 103 of file SHM_Transporter.unix.cpp.

References _attached, _shmSegCreated, buf, Transporter::isServer, make_error_info(), perror(), Transporter::report_error(), setupBuffersDone, shmBuf, shmId, and TE_SHM_UNABLE_TO_REMOVE_SEGMENT.

00103                                {
00104   if(_attached){
00105     const int res = shmdt(shmBuf);
00106     if(res == -1){
00107       perror("shmdelete: ");
00108       return;   
00109     }
00110     _attached = false;
00111     if(!isServer && _shmSegCreated)
00112       _shmSegCreated = false;
00113   }
00114   
00115   if(isServer && _shmSegCreated){
00116     const int res = shmctl(shmId, IPC_RMID, 0);
00117     if(res == -1){
00118       char buf[64];
00119       make_error_info(buf, sizeof(buf));
00120       report_error(TE_SHM_UNABLE_TO_REMOVE_SEGMENT);
00121       return;
00122     }
00123     _shmSegCreated = false;
00124   }
00125   setupBuffersDone=false;
00126 }

Here is the call graph for this function:

void SHM_Transporter::doSend ( ) [protected]

doSend (i.e signal receiver)

Definition at line 364 of file SHM_Transporter.cpp.

References g_ndb_shm_signum, m_last_signal, and m_remote_pid.

Referenced by updateWritePtr().

00365 {
00366   if(m_last_signal)
00367   {
00368     m_last_signal = 0;
00369     kill(m_remote_pid, g_ndb_shm_signum);
00370   }
00371 }

Here is the caller graph for this function:

Uint32 SHM_Transporter::get_free_buffer ( ) const [protected, virtual]

Implements Transporter.

Definition at line 374 of file SHM_Transporter.cpp.

References SHM_Writer::get_free_buffer(), and writer.

00375 {
00376   return writer->get_free_buffer();
00377 }

Here is the call graph for this function:

void SHM_Transporter::getReceivePtr	(	Uint32 **	ptr,
		Uint32 **	eod
	)			`[inline]`

Definition at line 73 of file SHM_Transporter.hpp.

References SHM_Reader::getReadPtr(), and reader.

Referenced by TransporterRegistry::performReceive().

00073                                                   {
00074     reader->getReadPtr(* ptr, * eod);
00075   }

Here is the call graph for this function:

Here is the caller graph for this function:

Uint32* SHM_Transporter::getWritePtr	(	Uint32	lenBytes,
		Uint32	prio
	)			`[inline, virtual]`

Implements Transporter.

Definition at line 58 of file SHM_Transporter.hpp.

References SHM_Writer::getWritePtr(), and writer.

00059   {
00060     return (Uint32 *)writer->getWritePtr(lenBytes);
00061   }

Here is the call graph for this function:

bool SHM_Transporter::hasDataToRead ( ) const [inline, private]

Returns:: - True if the reader has data to read on its segment.

Definition at line 170 of file SHM_Transporter.hpp.

References SHM_Reader::empty(), and reader.

00170                              {
00171     return reader->empty() == false;
00172   }

Here is the call graph for this function:

bool SHM_Transporter::initTransporter ( ) [virtual]

Do initialization

Implements Transporter.

Definition at line 72 of file SHM_Transporter.cpp.

References g_ndb_shm_signum.

Referenced by TransporterRegistry::createSHMTransporter().

00072                                 {
00073   if (g_ndb_shm_signum)
00074     return true;
00075   return false;
00076 }

Here is the caller graph for this function:

void SHM_Transporter::make_error_info	(	char	info[],
		int	sz
	)			`[private]`

Definition at line 29 of file SHM_Transporter.unix.cpp.

References shmId, shmKey, and shmSize.

Referenced by checkConnected(), connect_client_impl(), connect_server_impl(), and disconnectImpl().

00030 {
00031   snprintf(info,sz,"Shm key=%d sz=%d id=%d",
00032            shmKey, shmSize, shmId);
00033 }

Here is the caller graph for this function:

bool SHM_Transporter::ndb_shm_attach ( ) [protected]

Definition at line 58 of file SHM_Transporter.unix.cpp.

References perror(), shmBuf, and shmId.

Referenced by connect_client_impl(), and connect_server_impl().

00059 {
00060   shmBuf = (char *)shmat(shmId, 0, 0);
00061   if(shmBuf == 0) {
00062     perror("shmat: ");
00063     return false;
00064   }
00065   return true;
00066 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool SHM_Transporter::ndb_shm_create ( ) [protected]

Definition at line 36 of file SHM_Transporter.unix.cpp.

References perror(), shmId, shmKey, and shmSize.

Referenced by connect_server_impl().

00037 {
00038   shmId = shmget(shmKey, shmSize, IPC_CREAT | 960);
00039   if(shmId == -1) {
00040     perror("shmget: ");
00041     return false;
00042   }
00043   return true;
00044 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool SHM_Transporter::ndb_shm_get ( ) [protected]

Definition at line 47 of file SHM_Transporter.unix.cpp.

References perror(), shmId, shmKey, and shmSize.

Referenced by connect_client_impl().

00048 {
00049   shmId = shmget(shmKey, shmSize, 0);
00050   if(shmId == -1) {
00051     perror("shmget: ");
00052     return false;
00053   }
00054   return true;
00055 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SHM_Transporter::setupBuffers ( ) [protected]

Initialises the SHM_Reader and SHM_Writer on the segment

NOTE: There is 7th shared variable in Win2k (sharedCountAttached).

Definition at line 79 of file SHM_Transporter.cpp.

References SHM_Writer::clear(), SHM_Reader::clear(), clientStatusFlag, Transporter::isServer, Transporter::localNodeId, MAX_MESSAGE_SIZE, reader, Transporter::remoteNodeId, serverStatusFlag, shmBuf, shmSize, and writer.

Referenced by connect_common().

00079                              {
00080   Uint32 sharedSize = 0;
00081   sharedSize += 28; //SHM_Reader::getSharedSize();
00082   sharedSize += 28; //SHM_Writer::getSharedSize();
00083 
00084   const Uint32 slack = MAX_MESSAGE_SIZE;
00085 
00089   Uint32 sizeOfBuffer = shmSize;
00090   sizeOfBuffer -= 2*sharedSize;
00091   sizeOfBuffer /= 2;
00092 
00093   Uint32 * base1 = (Uint32*)shmBuf;
00094 
00095   Uint32 * sharedReadIndex1 = base1;
00096   Uint32 * sharedWriteIndex1 = base1 + 1;
00097   serverStatusFlag = base1 + 4;
00098   char * startOfBuf1 = shmBuf+sharedSize;
00099 
00100   Uint32 * base2 = (Uint32*)(shmBuf + sizeOfBuffer + sharedSize);
00101   Uint32 * sharedReadIndex2 = base2;
00102   Uint32 * sharedWriteIndex2 = base2 + 1;
00103   clientStatusFlag = base2 + 4;
00104   char * startOfBuf2 = ((char *)base2)+sharedSize;
00105   
00106   if(isServer){
00107     * serverStatusFlag = 0;
00108     reader = new SHM_Reader(startOfBuf1, 
00109                             sizeOfBuffer,
00110                             slack,
00111                             sharedReadIndex1,
00112                             sharedWriteIndex1);
00113 
00114     writer = new SHM_Writer(startOfBuf2, 
00115                             sizeOfBuffer,
00116                             slack,
00117                             sharedReadIndex2,
00118                             sharedWriteIndex2);
00119 
00120     * sharedReadIndex1 = 0;
00121     * sharedWriteIndex1 = 0;
00122 
00123     * sharedReadIndex2 = 0;
00124     * sharedWriteIndex2 = 0;
00125     
00126     reader->clear();
00127     writer->clear();
00128     
00129     * serverStatusFlag = 1;
00130 
00131 #ifdef DEBUG_TRANSPORTER 
00132     printf("-- (%d - %d) - Server -\n", localNodeId, remoteNodeId);
00133     printf("Reader at: %d (%p)\n", startOfBuf1 - shmBuf, startOfBuf1);
00134     printf("sharedReadIndex1 at %d (%p) = %d\n", 
00135            (char*)sharedReadIndex1-shmBuf, 
00136            sharedReadIndex1, *sharedReadIndex1);
00137     printf("sharedWriteIndex1 at %d (%p) = %d\n", 
00138            (char*)sharedWriteIndex1-shmBuf, 
00139            sharedWriteIndex1, *sharedWriteIndex1);
00140 
00141     printf("Writer at: %d (%p)\n", startOfBuf2 - shmBuf, startOfBuf2);
00142     printf("sharedReadIndex2 at %d (%p) = %d\n", 
00143            (char*)sharedReadIndex2-shmBuf, 
00144            sharedReadIndex2, *sharedReadIndex2);
00145     printf("sharedWriteIndex2 at %d (%p) = %d\n", 
00146            (char*)sharedWriteIndex2-shmBuf, 
00147            sharedWriteIndex2, *sharedWriteIndex2);
00148 
00149     printf("sizeOfBuffer = %d\n", sizeOfBuffer);
00150 #endif
00151   } else {
00152     * clientStatusFlag = 0;
00153     reader = new SHM_Reader(startOfBuf2, 
00154                             sizeOfBuffer,
00155                             slack,
00156                             sharedReadIndex2,
00157                             sharedWriteIndex2);
00158     
00159     writer = new SHM_Writer(startOfBuf1, 
00160                             sizeOfBuffer,
00161                             slack,
00162                             sharedReadIndex1,
00163                             sharedWriteIndex1);
00164     
00165     * sharedReadIndex2 = 0;
00166     * sharedWriteIndex1 = 0;
00167     
00168     reader->clear();
00169     writer->clear();
00170     * clientStatusFlag = 1;
00171 #ifdef DEBUG_TRANSPORTER
00172     printf("-- (%d - %d) - Client -\n", localNodeId, remoteNodeId);
00173     printf("Reader at: %d (%p)\n", startOfBuf2 - shmBuf, startOfBuf2);
00174     printf("sharedReadIndex2 at %d (%p) = %d\n", 
00175            (char*)sharedReadIndex2-shmBuf, 
00176            sharedReadIndex2, *sharedReadIndex2);
00177     printf("sharedWriteIndex2 at %d (%p) = %d\n", 
00178            (char*)sharedWriteIndex2-shmBuf, 
00179            sharedWriteIndex2, *sharedWriteIndex2);
00180 
00181     printf("Writer at: %d (%p)\n", startOfBuf1 - shmBuf, startOfBuf1);
00182     printf("sharedReadIndex1 at %d (%p) = %d\n", 
00183            (char*)sharedReadIndex1-shmBuf, 
00184            sharedReadIndex1, *sharedReadIndex1);
00185     printf("sharedWriteIndex1 at %d (%p) = %d\n", 
00186            (char*)sharedWriteIndex1-shmBuf, 
00187            sharedWriteIndex1, *sharedWriteIndex1);
00188     
00189     printf("sizeOfBuffer = %d\n", sizeOfBuffer);
00190 #endif
00191   }
00192 #ifdef DEBUG_TRANSPORTER
00193   printf("Mapping from %p to %p\n", shmBuf, shmBuf+shmSize);
00194 #endif
00195 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SHM_Transporter::updateReceivePtr ( Uint32 * ptr ) [inline]

Definition at line 77 of file SHM_Transporter.hpp.

References reader, and SHM_Reader::updateReadPtr().

Referenced by TransporterRegistry::performReceive().

00077                                      {
00078     reader->updateReadPtr(ptr);
00079   }

Here is the call graph for this function:

Here is the caller graph for this function:

void SHM_Transporter::updateWritePtr	(	Uint32	lenBytes,
		Uint32	prio
	)			`[inline, virtual]`

Implements Transporter.

Definition at line 63 of file SHM_Transporter.hpp.

References doSend(), m_last_signal, m_signal_threshold, SHM_Writer::updateWritePtr(), and writer.

00064   {
00065     writer->updateWritePtr(lenBytes);
00066     m_last_signal += lenBytes;
00067     if(m_last_signal >= m_signal_threshold)
00068     {
00069       doSend();
00070     }
00071   }