#include <RemoteQueue.h>

Inheritance diagram for CPN::RemoteQueue:

Collaboration diagram for CPN::RemoteQueue:

Public Types
enum	Mode_t { READ, WRITE }

Public Member Functions
	RemoteQueue (KernelBase k, Mode_t mode, ConnectionServer s, RemoteQueueHolder *h, const SimpleQueueAttr &attr, bool usembs)

	~RemoteQueue ()

void	Start ()

Mode_t	GetMode () const

Key_t	GetKey () const

void	Shutdown ()

void	LogState ()
	For debug ONLY! More...

const void *	GetRawDequeuePtr (unsigned thresh, unsigned chan)

void	Dequeue (unsigned count)

bool	RawDequeue (void *data, unsigned count, unsigned numChans, unsigned chanStride)

bool	RawDequeue (void *data, unsigned count)

void *	GetRawEnqueuePtr (unsigned thresh, unsigned chan)

void	Enqueue (unsigned count)

void	RawEnqueue (const void *data, unsigned count, unsigned numChans, unsigned chanStride)

void	RawEnqueue (const void *data, unsigned count)

void	Reset ()

void	Flush ()

bool	Flushed () const

unsigned	NumChannels () const

unsigned	Count () const

bool	Empty () const

unsigned	Freespace () const

bool	Full () const

unsigned	MaxThreshold () const

unsigned	QueueLength () const

unsigned	EnqueueChannelStride () const

unsigned	DequeueChannelStride () const

void	Grow (unsigned queueLen, unsigned maxThresh)

Key_t	GetWriterKey () const

Key_t	GetReaderKey () const

const std::string &	GetDatatype () const

void	ShutdownReader ()
	Called by the QueueReader when no more data will be read. More...

void	ShutdownWriter ()
	Called by the QueueWriter when no more data will be written. More...

void	NotifyTerminate ()
	Used to tell any waiting threads that the network is terminating. More...

void	Lock () const

void	Unlock () const

unsigned	ReadRequest ()
	For unit tests. More...

unsigned	WriteRequest ()
	For unit tests. More...

bool	IsReaderShutdown ()

bool	IsWriterShutdown ()

unsigned	NumEnqueued () const

unsigned	NumDequeued () const

void	SetReaderNode (shared_ptr< Node > n)

void	SetWriterNode (shared_ptr< Node > n)


void	SignalReaderTagChanged ()

void	SignalWriterTagChanged ()

Protected Member Functions
virtual void *	InternalGetRawEnqueuePtr (unsigned thresh, unsigned chan)

virtual const void *	InternalGetRawDequeuePtr (unsigned thresh, unsigned chan)

virtual unsigned	UnlockedNumChannels () const

virtual unsigned	UnlockedMaxThreshold () const

virtual unsigned	UnlockedFreespace () const

virtual bool	UnlockedFull () const

virtual unsigned	UnlockedEnqueueChannelStride () const

virtual unsigned	UnlockedDequeueChannelStride () const

unsigned	UnlockedNumEnqueued () const

unsigned	UnlockedNumDequeued () const

virtual bool	ReadBlocked ()

void	NotifyData ()

virtual bool	WriteBlocked ()

void	NotifyFreespace ()

virtual void	Wait ()

virtual void	Detect ()

virtual void	UnlockedShutdownReader ()

virtual void	UnlockedShutdownWriter ()

void	ReadBlock ()

void	WriteBlock (unsigned qsize)

Protected Attributes
TQImpl *	queue

TQImpl *	oldqueue

bool	enqueueUseOld

bool	dequeueUseOld

const Key_t	readerkey

const Key_t	writerkey

bool	readshutdown

bool	writeshutdown

unsigned	prepad

unsigned	postpad

unsigned	readrequest

unsigned	writerequest

unsigned	enqueuethresh

unsigned	dequeuethresh

bool	indequeue

bool	inenqueue

bool	flushed

KernelBase *	kernel

bool	useD4R

Logger	logger

PthreadMutex	lock

PthreadCondition	cond

std::string	datatype

shared_ptr< Node >	reader

shared_ptr< Node >	writer

bool	readtagchanged

bool	writetagchanged

bool	incomm

Private Member Functions
void	UnlockedShutdown ()

unsigned	UnlockedCount () const

bool	UnlockedEmpty () const

unsigned	UnlockedQueueLength () const

void	UnlockedGrow (unsigned queueLen, unsigned maxThresh)

void	Signal ()

void	WaitForData ()

void	WaitForFreespace ()

void	InternalDequeue (unsigned count)

void	InternalEnqueue (unsigned count)

void	InternalFlush ()

void	InternalReset ()

void	UnlockedSignalReaderTagChanged ()

void	UnlockedSignalWriterTagChanged ()

void	SetupPacket (Packet &packet)

void	EnqueuePacket (const Packet &packet)

void	SendEnqueuePacket ()

void	DequeuePacket (const Packet &packet)

void	SendDequeuePacket ()

void	ReadBlockPacket (const Packet &packet)

void	SendReadBlockPacket ()

void	WriteBlockPacket (const Packet &packet)

void	SendWriteBlockPacket ()

void	EndOfWritePacket (const Packet &packet)

void	SendEndOfWritePacket ()

void	EndOfReadPacket (const Packet &packet)

void	SendEndOfReadPacket ()

void	GrowPacket (const Packet &packet)

void	SendGrowPacket ()

void	D4RTagPacket (const Packet &packet)

void	SendD4RTagPacket ()

void	FlushPacket (const Packet &packet)

void	SendFlushPacket ()

void	ResetPacket (const Packet &packet)

void	SendResetPacket ()

void	IDReaderPacket (const Packet &packet)

void	IDWriterPacket (const Packet &packet)

void	Read ()

void	WriteBytes (const iovec *iov, unsigned iovcnt)

void *	FileThreadEntryPoint ()

void *	ActionThreadEntryPoint ()

void	InternalCheckStatus ()

void	UpdateClock (const Packet &packet)

void	TickClock ()

std::string	ClockString () const

void	HandleError (const ErrnoException &e)

std::string	GetState ()
	For debugging. More...

template<typename Queue_t >
void	SendEnqueue (const Packet &packet, Queue_t &queue)

void	SendPacket (const Packet &packet)

void	SendPacket (const Packet &packet, void *data)

void *	GetDecoderBytes (unsigned &amount)

void	ReleaseDecoderBytes (unsigned amount)

void	Reset ()

unsigned	NumBytes () const

void	FirePacket (const Packet &packet)

Static Private Member Functions
static unsigned	QueueLength (unsigned length, unsigned maxthresh, double alpha, Mode_t mode)

Private Attributes
auto_ptr< Pthread >	fileThread

auto_ptr< Pthread >	actionThread

bool	pendingAction

bool	actionTick

PthreadCondition	actionCond

const Mode_t	mode

const double	alpha

unsigned	maxwritethreshold

ConnectionServer *const	server

RemoteQueueHolder *const	holder

SocketHandle	sock

shared_ptr< D4R::Node >	mocknode

uint64_t	clock

uint64_t	readclock

uint64_t	writeclock

unsigned	readerlength

unsigned	writerlength

unsigned	bytecount

bool	pendingBlock

bool	sentEnd

bool	pendingGrow

bool	pendingD4RTag

bool	tagUpdated

bool	pendingFlush

bool	pendingReset

bool	dead

Detailed Description

The RemoteQueue is a specialization of the ThresholdQueue which is split in half across a socket. This class works closely with ConnectionServer and RemoteQueueHolder.

Definition at line 49 of file RemoteQueue.h.

Member Enumeration Documentation

enum CPN::RemoteQueue::Mode_t

Enumerator
READ
WRITE

Definition at line 57 of file RemoteQueue.h.

Constructor & Destructor Documentation

CPN::RemoteQueue::RemoteQueue	(	KernelBase *	k,
		Mode_t	mode,
		ConnectionServer *	s,
		RemoteQueueHolder *	h,
		const SimpleQueueAttr &	attr,
		bool	usembs
	)

Definition at line 49 of file RemoteQueue.cc.

References actionThread, ActionThreadEntryPoint(), CreatePthreadFunctional(), fileThread, FileThreadEntryPoint(), CPN::QueueBase::logger, mocknode, mode, Logger::Name(), READ, CPN::QueueBase::readerkey, D4R::QueueBase::SetReaderNode(), D4R::QueueBase::SetWriterNode(), Logger::Trace(), and CPN::QueueBase::writerkey.

         : ThresholdQueue(k, attr,
                 QueueLength(attr.GetLength(), attr.GetMaxThreshold(), attr.GetAlpha(), mode_), usembs),
         pendingAction(false),
         actionTick(false),
         mode(mode_),
         alpha(attr.GetAlpha()),
         maxwritethreshold(attr.GetMaxWriteThreshold()),
         server(s),
         holder(h),
         mocknode(new D4R::Node(mode_ == READ ? attr.GetWriterNodeKey() : attr.GetReaderNodeKey())),
         clock(0),
         readclock(0),
         writeclock(0),
         readerlength(QueueLength(attr.GetLength(), attr.GetMaxThreshold(), attr.GetAlpha(), READ)),
         writerlength(QueueLength(attr.GetLength(), attr.GetMaxThreshold(), attr.GetAlpha(), WRITE)),
         bytecount(0),
         pendingBlock(false),
         sentEnd(false),
         pendingGrow(false),
         pendingD4RTag(false),
         tagUpdated(false),
         pendingFlush(false),
         pendingReset(false),
         dead(false)
     {
         PthreadAttr pattr;
         pattr.StackSize(1<<16); // magic number, the file thread shouldn't use any more than this
         fileThread = auto_ptr<Pthread>(CreatePthreadFunctional(this, &RemoteQueue::FileThreadEntryPoint, pattr));
         actionThread = auto_ptr<Pthread>(CreatePthreadFunctional(this, &RemoteQueue::ActionThreadEntryPoint));
         if (mode == READ) {
             SetWriterNode(mocknode);
         } else {
             SetReaderNode(mocknode);
         }
         std::ostringstream oss;
         oss << "RemoteQueue(m:";
         if (mode == READ) { oss << "r"; }
         else { oss << "w"; }
         oss << ", r:" << readerkey << ", w:" << writerkey << ")";
         logger.Name(oss.str());
         logger.Trace("Constructed");
     }

Here is the call graph for this function:

CPN::RemoteQueue::~RemoteQueue ( )

Definition at line 94 of file RemoteQueue.cc.

References actionCond, actionThread, ASSERT_ABORT, PthreadCondition::Broadcast(), ClockString(), dead, fileThread, FUNC_TRACE, CPN::QueueBase::logger, Signal(), and Logger::Trace().

                               {
         ASSERT_ABORT(dead, "Shutdown but not dead!?");
         Signal();
         actionCond.Broadcast();
         FUNC_TRACE(logger);
         std::string clockstr = ClockString();
         logger.Trace("Destructed (c: %s)", clockstr.c_str());
         fileThread->Start();
         fileThread->Join();
         actionThread->Start();
         actionThread->Join();
         fileThread.reset();
         actionThread.reset();
     }

Here is the call graph for this function:

Member Function Documentation

void * CPN::RemoteQueue::ActionThreadEntryPoint ( )

private

Definition at line 662 of file RemoteQueue.cc.

References actionCond, actionTick, PthreadCondition::Broadcast(), dead, InternalCheckStatus(), pendingAction, and CPN::QueueBase::Wait().

Referenced by RemoteQueue().

                                               {
         AutoLock<QueueBase> al(*this);
         while (!dead) {
             InternalCheckStatus();
             actionTick = true;
             actionCond.Broadcast();
             while(!pendingAction && !dead) {
                 Wait();
             }
             pendingAction = false;
         }
         return 0;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string CPN::RemoteQueue::ClockString ( ) const

private

Definition at line 819 of file RemoteQueue.cc.

References clock, readclock, and writeclock.

Referenced by FileThreadEntryPoint(), GetState(), HandleError(), InternalCheckStatus(), LogState(), and ~RemoteQueue().

                                              {
         std::ostringstream oss;
         oss << "<" << clock << "," << readclock << "," << writeclock << ">";
         return oss.str();
     }

Here is the caller graph for this function:

unsigned CPN::QueueBase::Count ( ) const

inherited

Returns: the number of bytes in the queue.

Definition at line 205 of file QueueBase.cc.

References CPN::QueueBase::UnlockedCount().

                                     {
         AutoLock<const QueueBase> al(*this);
         return UnlockedCount();
     }

Here is the call graph for this function:

void CPN::RemoteQueue::D4RTagPacket ( const Packet & packet )

privatevirtual

Implements CPN::PacketHandler.

Definition at line 458 of file RemoteQueue.cc.

References ASSERT, CPN::Packet::DataLength(), FUNC_TRACE, CPN::QueueBase::logger, mocknode, mode, FileHandle::Read(), Signal(), sock, tagUpdated, D4R::QueueBase::UnlockedSignalReaderTagChanged(), D4R::QueueBase::UnlockedSignalWriterTagChanged(), UpdateClock(), and WRITE.

                                                        {
         UpdateClock(packet);
         FUNC_TRACE(logger);
         ASSERT(packet.DataLength() == sizeof(D4R::Tag));
         D4R::Tag tag;
         unsigned numread = sock.Read(&tag, sizeof(tag));
         ASSERT(numread == sizeof(tag));
         tagUpdated = true;
         Signal();
         mocknode->SetPublicTag(tag);
         if (mode == WRITE) {
             QueueBase::UnlockedSignalReaderTagChanged();
         } else {
             QueueBase::UnlockedSignalWriterTagChanged();
         }
     }

Here is the call graph for this function:

void CPN::QueueBase::Dequeue ( unsigned count )

inherited

This function is used to remove elements from the queue. count elements will be removed from the queue when this function is called.

Parameters

count the number of bytes to remove from the queue

Definition at line 92 of file QueueBase.cc.

References CPN::QueueBase::dequeuethresh, CPN::QueueBase::GetRawDequeuePtr(), CPN::QueueBase::indequeue, CPN::QueueBase::InternalDequeue(), CPN::QueueBase::NotifyFreespace(), CPN::QueueBase::readerkey, and CPN::QueueBase::readshutdown.

Referenced by CPN::QueueBase::RawDequeue().

                                           {
         if (!GetRawDequeuePtr(count, 0)) { throw BrokenQueueException(readerkey); }
         AutoLock<QueueBase> al(*this);
         dequeuethresh = 0;
         indequeue = false;
         if (readshutdown) { throw BrokenQueueException(readerkey); }
         InternalDequeue(count);
         NotifyFreespace();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned CPN::QueueBase::DequeueChannelStride ( ) const

inherited

Returns: The current dequeue channel stride. This value is only guaranteed to be consistent inbetween a call to GetDequeuePtr and Dequeue.

Definition at line 240 of file QueueBase.cc.

References CPN::QueueBase::UnlockedDequeueChannelStride().

                                                    {
         AutoLock<const QueueBase> al(*this);
         return UnlockedDequeueChannelStride();
     }

Here is the call graph for this function:

void CPN::RemoteQueue::DequeuePacket ( const Packet & packet )

privatevirtual

Implements CPN::PacketHandler.

Definition at line 335 of file RemoteQueue.cc.

References ASSERT, bytecount, CPN::Packet::Count(), FUNC_TRACE, CPN::QueueBase::logger, mode, CPN::QueueBase::readrequest, CPN::QueueBase::readshutdown, UpdateClock(), and WRITE.

                                                         {
         UpdateClock(packet);
         FUNC_TRACE(logger);
         ASSERT(mode == WRITE);
         ASSERT(!readshutdown);
         readrequest = 0;
         bytecount -= packet.Count();
     }

Here is the call graph for this function:

void CPN::QueueBase::Detect ( )

protectedvirtualinherited

Called by the D4R algorithm when it has detected an artificial deadlock and this queue should be changed.

Implements D4R::QueueBase.

Definition at line 373 of file QueueBase.cc.

References CPN::KernelBase::CalculateGrowSize(), Logger::Debug(), CPN::QueueBase::kernel, CPN::QueueBase::logger, CPN::QueueBase::UnlockedCount(), CPN::QueueBase::UnlockedGrow(), CPN::QueueBase::UnlockedMaxThreshold(), CPN::QueueBase::UnlockedQueueLength(), and CPN::QueueBase::writerequest.

                            {
         unsigned size = kernel->CalculateGrowSize(UnlockedCount(), writerequest);
         logger.Debug("Detect: Grow(%u, %u)", size, writerequest);
         UnlockedGrow(size, writerequest);
         logger.Debug("New size: (%u, %u)", UnlockedQueueLength(), UnlockedMaxThreshold());
     }

Here is the call graph for this function:

bool CPN::QueueBase::Empty ( ) const

inherited

Returns: true if the queue is empty

Definition at line 210 of file QueueBase.cc.

References CPN::QueueBase::UnlockedEmpty().

                                 {
         AutoLock<const QueueBase> al(*this);
         return UnlockedEmpty();
     }

Here is the call graph for this function:

void CPN::RemoteQueue::EndOfReadPacket ( const Packet & packet )

privatevirtual

Implements CPN::PacketHandler.

Definition at line 417 of file RemoteQueue.cc.

References ASSERT, FUNC_TRACE, CPN::QueueBase::logger, mode, CPN::QueueBase::readshutdown, CPN::QueueBase::UnlockedShutdownReader(), UpdateClock(), and WRITE.

                                                           {
         UpdateClock(packet);
         FUNC_TRACE(logger);
         ASSERT(mode == WRITE);
         ASSERT(!readshutdown);
         QueueBase::UnlockedShutdownReader();
     }

Here is the call graph for this function:

void CPN::RemoteQueue::EndOfWritePacket ( const Packet & packet )

privatevirtual

Implements CPN::PacketHandler.

Definition at line 396 of file RemoteQueue.cc.

References ASSERT, FUNC_TRACE, CPN::QueueBase::logger, mode, READ, CPN::QueueBase::UnlockedShutdownWriter(), UpdateClock(), and CPN::QueueBase::writeshutdown.

                                                            {
         UpdateClock(packet);
         FUNC_TRACE(logger);
         ASSERT(mode == READ);
         ASSERT(!writeshutdown);
         QueueBase::UnlockedShutdownWriter();
     }

Here is the call graph for this function:

void CPN::QueueBase::Enqueue ( unsigned count )

inherited

This function is used to release the buffer obtained with GetRawEnqueuePtr. The count specifies the number of entries that we want to be placed in the buffer.

Note: A call to this function without an accompanying call to GetRawEnqueuePtr is undefined.

Parameters

count the number of bytes to be placed in the buffer

Invariant: count <= thresh from GetRawEnqueuePtr

Definition at line 160 of file QueueBase.cc.

References CPN::QueueBase::enqueuethresh, CPN::QueueBase::inenqueue, CPN::QueueBase::InternalEnqueue(), CPN::QueueBase::NotifyData(), CPN::QueueBase::writerkey, and CPN::QueueBase::writeshutdown.

Referenced by CPN::ThresholdQueue::TQImpl::Grow(), and CPN::QueueBase::RawEnqueue().

                                           {
         AutoLock<QueueBase> al(*this);
         enqueuethresh = 0;
         inenqueue = false;
         if (writeshutdown) { throw BrokenQueueException(writerkey); }
         InternalEnqueue(count);
         NotifyData();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned CPN::QueueBase::EnqueueChannelStride ( ) const

inherited

Returns: The current enqueue channel stride. This value is only guaranteed to be consistent inbetween a call to GetEnqueuePtr and Enqueue.

Definition at line 235 of file QueueBase.cc.

References CPN::QueueBase::UnlockedEnqueueChannelStride().

                                                    {
         AutoLock<const QueueBase> al(*this);
         return UnlockedEnqueueChannelStride();
     }

Here is the call graph for this function:

void CPN::RemoteQueue::EnqueuePacket ( const Packet & packet )

privatevirtual

Implements CPN::PacketHandler.

Definition at line 242 of file RemoteQueue.cc.

References ASSERT, bytecount, clock, ThresholdQueueBase::Count(), CPN::Packet::Count(), CPN::Packet::DataLength(), FileHandle::Eof(), ThresholdQueueBase::Freespace(), FUNC_TRACE, CPN::QueueBase::inenqueue, CPN::ThresholdQueue::InternalEnqueue(), CPN::ThresholdQueue::InternalGetRawEnqueuePtr(), CPN::QueueBase::logger, ThresholdQueueBase::MaxThreshold(), mode, CPN::QueueBase::NotifyData(), ThresholdQueueBase::NumChannels(), CPN::ThresholdQueue::queue, ThresholdQueueBase::QueueLength(), READ, readclock, FileHandle::Readv(), sock, CPN::ThresholdQueue::UnlockedGrow(), UpdateClock(), Logger::Warn(), writeclock, CPN::QueueBase::writerequest, and CPN::QueueBase::writeshutdown.

                                                         {
         UpdateClock(packet);
         FUNC_TRACE(logger);
         ASSERT(mode == READ);
         ASSERT(!writeshutdown);
         const unsigned numchannels = queue->NumChannels();
         unsigned count = packet.Count();
         if (count > queue->Freespace() || count > queue->MaxThreshold()) {
             logger.Warn("Enqueue packet too large, silently growing queue. "
                     "Packet size: %u, Freespace: %u, MaxThresh: %u, QueueLength: %u",
                     count, queue->Freespace(), queue->MaxThreshold(), queue->QueueLength());
             ThresholdQueue::UnlockedGrow(queue->Count() + count, count);
         }
         std::vector<iovec> iovs;
         for (unsigned i = 0; i < numchannels; ++i) {
             iovec iov;
             iov.iov_base = ThresholdQueue::InternalGetRawEnqueuePtr(count, i);
             ASSERT(iov.iov_base, "Internal throttle failed! (c: <%llu,%llu,%llu>)", clock, readclock, writeclock);
             iov.iov_len = count;
             iovs.push_back(iov);
         }
         inenqueue = true;
         {
             AutoUnlock<QueueBase> aul(*this);
             unsigned numread = 0;
             unsigned numtoread = packet.DataLength();
             unsigned i = 0;
             while (numread < numtoread) {
                 unsigned num = sock.Readv(&iovs[i], iovs.size() - i);
                     if (num == 0) {
                         if (sock.Eof()) {
                             return;
                         }
                     }
                 numread += num;
                 if (numread == numtoread) break;
                 while (iovs[i].iov_len <= num) {
                     num -= iovs[i].iov_len;
                     ++i;
                 }
                 iovs[i].iov_len -= num;
                 iovs[i].iov_base = ((char*)iovs[i].iov_base) + num;
             }
             ASSERT(numread == packet.DataLength());
         }
         inenqueue = false;
         ThresholdQueue::InternalEnqueue(count);
         bytecount += count;
         writerequest = 0;
         NotifyData();
     }

Here is the call graph for this function:

void * CPN::RemoteQueue::FileThreadEntryPoint ( )

private

Definition at line 583 of file RemoteQueue.cc.

References actionCond, actionThread, actionTick, CPN::RemoteQueueHolder::CleanupQueue(), ClockString(), FileHandle::Closed(), CPN::ConnectionServer::ConnectReader(), CPN::ConnectionServer::ConnectWriter(), dead, Logger::Debug(), Logger::Error(), FileHandle::FD(), GetKey(), CPN::RemoteQueueHolder::GetWakeup(), HandleError(), holder, CPN::KernelBase::IsTerminated(), CPN::QueueBase::kernel, CPN::QueueBase::lock, CPN::QueueBase::logger, mode, FileHandle::Poll(), FileHandle::Reset(), server, SocketHandle::SetNoDelay(), Shutdown(), CPN::QueueBase::ShutdownReader(), CPN::QueueBase::ShutdownWriter(), Signal(), sock, PthreadCondition::Wait(), CPN::ConnectionServer::Wakeup(), ErrnoException::what(), and WRITE.

Referenced by RemoteQueue().

                                             {
         try {
             while (true) {
                 try {
                     if (kernel->IsTerminated()) {
                         std::string clockstr = ClockString();
                         logger.Debug("Forced Shutdown (c: %s)", clockstr.c_str());
                         Shutdown();
                     }
                     {
                         AutoLock<QueueBase> al(*this);
                         if (dead) {
                             std::string clockstr = ClockString();
                             logger.Debug("Shutdown (c: %s)", clockstr.c_str());
                             break;
                         }
                     }
                     if (sock.Closed()) {
                         logger.Debug("Connecting");
                         shared_ptr<Sync::Future<int> > conn;
                         if (mode == WRITE) {
                             conn = server->ConnectWriter(GetKey());
                         } else {
                             conn = server->ConnectReader(GetKey());
                         }
                         if (conn) {
                             sock.Reset();
                             sock.FD(conn->Get());
                         }
                         if (sock.Closed()) {
                             logger.Debug("Connection Failed");
                         } else {
                             logger.Debug("Connected");
                             actionThread->Start();
                             sock.SetNoDelay(true);
                         }
                     } else {
                         FileHandle *fds[2];
                         fds[0] = &sock;
                         fds[1] = holder->GetWakeup();
                         FileHandle::Poll(fds, fds+2, -1);
                         {
                             AutoLock<QueueBase> al(*this);
                             Signal();
                             actionTick = false;
                             while (!actionTick && !dead) {
                                 actionCond.Wait(lock);
                             }
                         }
                     }
                 } catch (const ErrnoException &e) {
                     AutoLock<QueueBase> al(*this);
                     HandleError(e);
                 }
             }
         } catch (const ShutdownException &e) {
             std::string clockstr = ClockString();
             logger.Debug("Forced Shutdown threw exception (c: %s)", clockstr.c_str());
             // Do nothing, this just breaks us out of the loop
             // Can be thrown from ConnectWriter or ConnectReader
         } catch (const ErrnoException &e) {
             logger.Error(e.what());
             ShutdownReader();
             ShutdownWriter();
             Shutdown();
         } catch (...) {
             holder->CleanupQueue(GetKey());
             throw;
         }
         holder->CleanupQueue(GetKey());
         server->Wakeup();
         return 0;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::PacketHandler::FirePacket ( const Packet & packet )

inherited

Definition at line 31 of file PacketHeader.cc.

Referenced by CPN::PacketDecoder::ReleaseDecoderBytes().

                                                        {
         ASSERT(packet.Valid(), "Invalid packet");
         switch (packet.Type()) {
         case PACKET_ENQUEUE:
             EnqueuePacket(packet);
             break;
         case PACKET_DEQUEUE:
             DequeuePacket(packet);
             break;
         case PACKET_READBLOCK:
             ReadBlockPacket(packet);
             break;
         case PACKET_WRITEBLOCK:
             WriteBlockPacket(packet);
             break;
         case PACKET_ENDOFWRITE:
             EndOfWritePacket(packet);
             break;
         case PACKET_ENDOFREAD:
             EndOfReadPacket(packet);
             break;
         case PACKET_GROW:
             GrowPacket(packet);
             break;
         case PACKET_D4RTAG:
             D4RTagPacket(packet);
             break;
         case PACKET_FLUSH:
             FlushPacket(packet);
             break;
         case PACKET_RESET:
             ResetPacket(packet);
             break;
         case PACKET_ID_READER:
             IDReaderPacket(packet);
             break;
         case PACKET_ID_WRITER:
             IDWriterPacket(packet);
             break;
         default:
             ASSERT(false, "Invalid packet type.");
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::QueueBase::Flush ( )

inherited

Definition at line 186 of file QueueBase.cc.

References CPN::QueueBase::InternalFlush().

                           {
         AutoLock<const QueueBase> al(*this);
         InternalFlush();
     }

Here is the call graph for this function:

bool CPN::QueueBase::Flushed ( ) const

inherited

Definition at line 191 of file QueueBase.cc.

References CPN::QueueBase::flushed.

                                   {
         AutoLock<const QueueBase> al(*this);
         return flushed;
     }

void CPN::RemoteQueue::FlushPacket ( const Packet & packet )

privatevirtual

Implements CPN::PacketHandler.

Definition at line 489 of file RemoteQueue.cc.

References CPN::QueueBase::flushed, FUNC_TRACE, CPN::QueueBase::logger, Signal(), and UpdateClock().

                                                       {
         UpdateClock(packet);
         FUNC_TRACE(logger);
         flushed = true;
         Signal();
     }

Here is the call graph for this function:

unsigned CPN::QueueBase::Freespace ( ) const

inherited

Returns: the number of bytes we can add to the queue without blocking.

Definition at line 215 of file QueueBase.cc.

References CPN::QueueBase::UnlockedFreespace().

                                         {
         AutoLock<const QueueBase> al(*this);
         return UnlockedFreespace();
     }

Here is the call graph for this function:

bool CPN::QueueBase::Full ( ) const

inherited

Returns: true if the queue is full, false otherwise

Definition at line 220 of file QueueBase.cc.

References CPN::QueueBase::UnlockedFull().

                                {
         AutoLock<const QueueBase> al(*this);
         return UnlockedFull();
     }

Here is the call graph for this function:

const std::string& CPN::QueueBase::GetDatatype ( ) const

inlineinherited

Returns: the datatype name associated with this queue

Definition at line 213 of file QueueBase.h.

213 { return datatype; }

CPN::QueueBase::datatype

std::string datatype

Definition: QueueBase.h:291

void * CPN::PacketDecoder::GetDecoderBytes ( unsigned & amount )

inherited

Definition at line 37 of file PacketDecoder.cc.

References ASSERT, CPN::PacketDecoder::header, CPN::Packet::header, and CPN::PacketDecoder::numbytes.

Referenced by Read().

                                                          {
         char *ptr = reinterpret_cast<char*>(&header.header);
         amount = sizeof(header.header) - numbytes;
         ASSERT(amount != 0, "Zero decoder bytes");
         return ptr + numbytes;
     }

Here is the caller graph for this function:

Key_t CPN::RemoteQueue::GetKey ( ) const

inlinevirtual

Implements CPN::RemoteQueueBase.

Definition at line 74 of file RemoteQueue.h.

References mode, READ, CPN::QueueBase::readerkey, and CPN::QueueBase::writerkey.

Referenced by FileThreadEntryPoint().

74 { return mode == READ ? readerkey : writerkey; }

CPN::RemoteQueue::READ

Definition: RemoteQueue.h:58

CPN::QueueBase::readerkey

const Key_t readerkey

Definition: QueueBase.h:273

CPN::RemoteQueue::mode

const Mode_t mode

Definition: RemoteQueue.h:148

CPN::QueueBase::writerkey

const Key_t writerkey

Definition: QueueBase.h:274

Here is the caller graph for this function:

Mode_t CPN::RemoteQueue::GetMode ( ) const

inline

Definition at line 73 of file RemoteQueue.h.

References mode.

73 { return mode; }

CPN::RemoteQueue::mode

const Mode_t mode

Definition: RemoteQueue.h:148

const void * CPN::QueueBase::GetRawDequeuePtr	(	unsigned	thresh,
		unsigned	chan
	)

inherited

Get a pointer to a buffer containing elements.

Note: access to the memory locations pointed to by the returned pointer after Dequeue has been called is undefined.

Parameters

thresh	the number of bytes to get
chan	the channel to use

Returns: A void* to a block of memory containing thresh bytes or 0 if there are not thresh bytes available.

Definition at line 63 of file QueueBase.cc.

References ASSERT, CPN::KernelBase::CheckTerminated(), CPN::QueueBase::dequeuethresh, CPN::QueueBase::flushed, CPN::KernelBase::GrowQueueMaxThreshold(), CPN::QueueBase::indequeue, CPN::QueueBase::InternalGetRawDequeuePtr(), CPN::QueueBase::kernel, CPN::QueueBase::readerkey, CPN::QueueBase::readrequest, CPN::QueueBase::readshutdown, CPN::QueueBase::Signal(), CPN::QueueBase::UnlockedGrow(), CPN::QueueBase::UnlockedMaxThreshold(), CPN::QueueBase::WaitForData(), CPN::QueueBase::WriteBlocked(), CPN::QueueBase::writerequest, and CPN::QueueBase::writeshutdown.

Referenced by CPN::QueueBase::Dequeue(), and CPN::QueueBase::RawDequeue().

                                                                           {
         kernel->CheckTerminated();
         AutoLock<QueueBase> al(*this);
         if (indequeue) { ASSERT(dequeuethresh >= thresh); }
         else { dequeuethresh = thresh; }
         while (true) {
             const void *ptr = InternalGetRawDequeuePtr(thresh, chan);
             if (ptr ||
                     (writeshutdown && !(thresh > UnlockedMaxThreshold() && kernel->GrowQueueMaxThreshold()))
                     || flushed) {
                 if (ptr) { indequeue = true; }
                 return ptr;
             }
             if (readshutdown) { throw BrokenQueueException(readerkey); }
             if (thresh > UnlockedMaxThreshold() && kernel->GrowQueueMaxThreshold()) {
                 //printf("Grow(%u, %u)\n", 2*thresh, thresh);
                 UnlockedGrow(2*thresh, thresh);
                 Signal();
             } else if (WriteBlocked() && kernel->GrowQueueMaxThreshold()) {
                 UnlockedGrow(writerequest + thresh, thresh);
                 Signal();
             } else {
                 readrequest = thresh;
                 WaitForData();
                 readrequest = 0;
             }
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void * CPN::QueueBase::GetRawEnqueuePtr	(	unsigned	thresh,
		unsigned	chan
	)

inherited

Return a pointer to a buffer of memory that contains thresh entries that we can write into.

Note: A call to this function without an accompanying call to Enqueue is undefined.; An access to the memory locations defined by the return value is undefined after a call to Enqueue.

Parameters

thresh	the number bytes we need in the returned buffer.
chan	the channel to use

Returns: void* to the memory buffer, 0 if not enough space available

Definition at line 121 of file QueueBase.cc.

Referenced by CPN::ThresholdQueue::TQImpl::Grow(), and CPN::QueueBase::RawEnqueue().

                                                                     {
         kernel->CheckTerminated();
         AutoLock<QueueBase> al(*this);
         // Only the enqueuer may call flush and reset will clear all state as if we
         // had not done anything yet, so block here
         while (flushed) {
             if (readshutdown || writeshutdown) { throw BrokenQueueException(writerkey); }
             if (useD4R) {
                 WriteBlock(-1);
             } else {
                 Wait();
             }
         }
         if (inenqueue) { ASSERT(enqueuethresh >= thresh); }
         else { enqueuethresh = thresh; }
         bool grown = false;
         while (true) {
             void *ptr = InternalGetRawEnqueuePtr(thresh, chan);
             if (ptr) {
                 inenqueue = true;
                 return ptr;
             }
             if (readshutdown || writeshutdown) { throw BrokenQueueException(writerkey); }
             if (thresh > UnlockedMaxThreshold() && kernel->GrowQueueMaxThreshold()) {
                 //printf("Grow(%u, %u)\n", 2*thresh, thresh);
                 UnlockedGrow(2*thresh, thresh);
                 Signal();
             } else if (!grown && ReadBlocked() && kernel->GrowQueueMaxThreshold()) {
                 UnlockedGrow(readrequest + thresh, thresh);
                 Signal();
                 grown = true;
             } else {
                 writerequest = thresh;
                 WaitForFreespace();
                 writerequest = 0;
             }
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

Key_t CPN::QueueBase::GetReaderKey ( ) const

inlineinherited

Returns: the reader key associated with this queue

Definition at line 211 of file QueueBase.h.

211 { return readerkey; }

CPN::QueueBase::readerkey

const Key_t readerkey

Definition: QueueBase.h:273

std::string CPN::RemoteQueue::GetState ( )

private

For debugging.

Definition at line 867 of file RemoteQueue.cc.

References bytecount, ClockString(), dead, mode, pendingBlock, pendingD4RTag, pendingGrow, READ, readerlength, CPN::QueueBase::readrequest, CPN::QueueBase::readshutdown, sentEnd, UnlockedCount(), CPN::ThresholdQueue::UnlockedFreespace(), CPN::ThresholdQueue::UnlockedMaxThreshold(), CPN::ThresholdQueue::UnlockedNumDequeued(), CPN::ThresholdQueue::UnlockedNumEnqueued(), UnlockedQueueLength(), CPN::QueueBase::writerequest, writerlength, and CPN::QueueBase::writeshutdown.

                                     {
         std::ostringstream oss;
         oss << "s: " << UnlockedQueueLength() << ",mt: " << UnlockedMaxThreshold() << ",c: " << UnlockedCount()
             << ",f: " << UnlockedFreespace() << ",rr: " << readrequest << ",wr: " << writerequest
             << ",te: " << UnlockedNumEnqueued() << ",td: " << UnlockedNumDequeued()
             << ",M: " << (mode == READ ? "r" : "w") << ",rl: " << readerlength
             << ",wl: " << writerlength << ",c: " << ClockString() << ",bc: "
             << bytecount << ",pb: " << pendingBlock << ",se: " << sentEnd
             << ",pg: " << pendingGrow << ",pd4r: " << pendingD4RTag
             << ",d: " << dead;
         if (readshutdown) {
             oss << ",readshutdown";
         }
         if (writeshutdown) {
             oss << ",writeshutdown";
         }
         return oss.str();
     }

Here is the call graph for this function:

Key_t CPN::QueueBase::GetWriterKey ( ) const

inlineinherited

Returns: the writer key associated with this queue

Definition at line 209 of file QueueBase.h.

209 { return writerkey; }

CPN::QueueBase::writerkey

const Key_t writerkey

Definition: QueueBase.h:274

void CPN::QueueBase::Grow	(	unsigned	queueLen,
		unsigned	maxThresh
	)

inherited

Ensure that this queue has at least queueLen bytes of space and can support at least maxThresh as the maxThreshold the new queue length will be max(queueLen, QueueLength()) and the new max threshold will be max(maxThresh, MaxThreshold())

Note: that the caller must guarantee that both an enqueue and dequeue are not both outstanding. Otherwise this will fail.

Parameters

queueLen	the next queue length
maxThresh	the next max threshold

Definition at line 245 of file QueueBase.cc.

References CPN::QueueBase::UnlockedGrow().

                                                               {
         AutoLock<QueueBase> al(*this);
         UnlockedGrow(queueLen, maxThresh);
     }

Here is the call graph for this function:

void CPN::RemoteQueue::GrowPacket ( const Packet & packet )

privatevirtual

Implements CPN::PacketHandler.

Definition at line 438 of file RemoteQueue.cc.

References alpha, FUNC_TRACE, CPN::QueueBase::logger, ThresholdQueueBase::MaxThreshold(), CPN::Packet::MaxThreshold(), mode, CPN::ThresholdQueue::queue, CPN::QueueBase::QueueLength(), CPN::Packet::QueueSize(), READ, readerlength, CPN::ThresholdQueue::UnlockedGrow(), UpdateClock(), WRITE, and writerlength.

                                                      {
         UpdateClock(packet);
         FUNC_TRACE(logger);
         const unsigned queueLen = packet.QueueSize();
         const unsigned maxthresh = std::max<unsigned>(queue->MaxThreshold(), packet.MaxThreshold());
         readerlength = QueueLength(queueLen, maxthresh, alpha, READ);
         writerlength = QueueLength(queueLen, maxthresh, alpha, WRITE);
         const unsigned newlen = (mode == WRITE ? writerlength : readerlength);
         ThresholdQueue::UnlockedGrow(newlen, maxthresh);
     }

Here is the call graph for this function:

void CPN::RemoteQueue::HandleError ( const ErrnoException & e )

private

Definition at line 825 of file RemoteQueue.cc.

References actionCond, PthreadCondition::Broadcast(), ClockString(), FileHandle::Close(), dead, ErrnoException::Error(), Logger::Error(), CPN::QueueBase::logger, CPN::QueueBase::readshutdown, Signal(), sock, ErrnoException::what(), and CPN::QueueBase::writeshutdown.

Referenced by FileThreadEntryPoint(), and InternalCheckStatus().

                                                          {
         if (readshutdown || writeshutdown) {
             Signal();
         }
         switch (e.Error()) {
         case EPIPE:
         case EBADF:
         case ECONNRESET:
             try {
                 sock.Close();
             } catch (const ErrnoException &e) {}
             dead = true;
             actionCond.Broadcast();
             break;
         default:
             {
                 std::string clockstr = ClockString();
                 logger.Error("Exception in RemoteQueue rethrowing (c: %s e: %d): %s",
                         clockstr.c_str(), e.Error(), e.what());
             }
             throw;
             break;
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::RemoteQueue::IDReaderPacket ( const Packet & packet )

privatevirtual

Implements CPN::PacketHandler.

Definition at line 532 of file RemoteQueue.cc.

References ASSERT.

                                                          {
         ASSERT(false, "Unexpected packet");
     }

void CPN::RemoteQueue::IDWriterPacket ( const Packet & packet )

privatevirtual

Implements CPN::PacketHandler.

Definition at line 536 of file RemoteQueue.cc.

References ASSERT.

                                                          {
         ASSERT(false, "Unexpected packet");
     }

void CPN::RemoteQueue::InternalCheckStatus ( )

private

Definition at line 676 of file RemoteQueue.cc.

References actionCond, ASSERT, PthreadCondition::Broadcast(), bytecount, ClockString(), FileHandle::Close(), FileHandle::Closed(), ThresholdQueueBase::Count(), dead, Logger::DEBUG, Logger::Debug(), ThresholdQueueBase::Empty(), FileHandle::Eof(), Logger::Error(), ThresholdQueueBase::Freespace(), HandleError(), CPN::KernelBase::IsTerminated(), CPN::QueueBase::kernel, CPN::QueueBase::logger, Logger::LogLevel(), LogState(), mode, pendingBlock, pendingD4RTag, pendingFlush, pendingGrow, pendingReset, CPN::ThresholdQueue::queue, Read(), D4R::QueueBase::reader, readerlength, CPN::QueueBase::readrequest, CPN::QueueBase::readshutdown, SendD4RTagPacket(), SendDequeuePacket(), SendEndOfReadPacket(), SendEndOfWritePacket(), SendEnqueuePacket(), SendFlushPacket(), SendGrowPacket(), SendReadBlockPacket(), SendResetPacket(), SendWriteBlockPacket(), sentEnd, sock, UnlockedShutdown(), CPN::QueueBase::UnlockedShutdownReader(), CPN::QueueBase::UnlockedShutdownWriter(), WRITE, D4R::QueueBase::writer, CPN::QueueBase::writerequest, and CPN::QueueBase::writeshutdown.

Referenced by ActionThreadEntryPoint().

                                           {
         if (sock.Closed()) {
             return;
         }
 
         bool terminated = kernel->IsTerminated();
         if (sock.Eof() && !(readshutdown || writeshutdown)) {
             if (terminated) {
                 if (!sock.Closed()) {
                     sock.Close();
                 }
                 UnlockedShutdown();
                 return;
             }
             // We /should/ never get here, output copious amounts of internal information.
             std::string clockstr = ClockString();
             logger.Error("Eof detected but not shutdown! (c: %s)", clockstr.c_str());
             LogState();
             ASSERT(false, "EOF detected but not shutdown! (c: %s)", clockstr.c_str());
         }
 
         try {
             Read();
 
             if (pendingGrow && !sentEnd) {
                 SendGrowPacket();
                 pendingGrow = false;
             }
 
             if (mode == WRITE) {
                 if (!sentEnd) {
                     if (terminated) {
                         QueueBase::UnlockedShutdownWriter();
                     }
                     // Write as much as we can
                     while (!queue->Empty() && (bytecount < readerlength) && !dead) {
                         SendEnqueuePacket();
                     }
                     if (dead) return;
                     if (pendingFlush && queue->Empty()) {
                         SendFlushPacket();
                     }
                     // A pending block is present
                     if (pendingBlock) {
                         // If we have received dequeue packets
                         // sense the block happened don't bother sending anything
                         if (writerequest > queue->Freespace()) {
                             SendWriteBlockPacket();
                         }
                         pendingBlock = false;
                     }
 
                     if (pendingD4RTag) {
                         if (writer && !writeshutdown) {
                             SendD4RTagPacket();
                             pendingD4RTag = false;
                         }
                     }
                 }
                 if (writeshutdown) {
                     if (!sentEnd && (queue->Empty() || terminated)) {
                         SendEndOfWritePacket();
                         sentEnd = true;
                     }
                 }
 
                 if (readshutdown) {
                     if (!sentEnd) {
                         SendEndOfWritePacket();
                         sentEnd = true;
                     }
                     if (logger.LogLevel() <= Logger::DEBUG) {
                         std::string clockstr = ClockString();
                         logger.Debug("Closing the socket (c: %s)", clockstr.c_str());
                     }
                     sock.Close();
                     dead = true;
                     actionCond.Broadcast();
                 }
             } else {
                 if (!sentEnd) {
                     if (terminated) {
                         QueueBase::UnlockedShutdownReader();
                     }
                     if (pendingReset) {
                         SendResetPacket();
                     }
                     // If some bytes have been read from the queue
                     if (bytecount > queue->Count()) {
                         SendDequeuePacket();
                     }
 
                     if (pendingBlock) {
                         // May have received enqueue packets...
                         if (readrequest > queue->Count()) {
                             SendReadBlockPacket();
                         }
                         pendingBlock = false;
                     }
                     if (pendingD4RTag) {
                         if (reader && !readshutdown) {
                             SendD4RTagPacket();
                             pendingD4RTag = false;
                         }
                     }
                     if (readshutdown) {
                         SendEndOfReadPacket();
                         sentEnd = true;
                     }
                 }
                 if (writeshutdown) {
                     if (!sentEnd) {
                         SendEndOfReadPacket();
                         sentEnd = true;
                     }
                     if (logger.LogLevel() <= Logger::DEBUG) {
                         std::string clockstr = ClockString();
                         logger.Debug("Closing the socket (c: %s)", clockstr.c_str());
                     }
                     sock.Close();
                     dead = true;
                     actionCond.Broadcast();
                 }
             }
         } catch (const ErrnoException &e) {
             HandleError(e);
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::RemoteQueue::InternalDequeue ( unsigned count )

privatevirtual

Reimplemented from CPN::ThresholdQueue.

Definition at line 191 of file RemoteQueue.cc.

References ASSERT, FUNC_TRACE, CPN::ThresholdQueue::InternalDequeue(), CPN::QueueBase::logger, mode, READ, and Signal().

                                                     {
         ASSERT(mode == READ);
         FUNC_TRACE(logger);
         ThresholdQueue::InternalDequeue(count);
         Signal();
     }

Here is the call graph for this function:

void CPN::RemoteQueue::InternalEnqueue ( unsigned count )

privatevirtual

Reimplemented from CPN::ThresholdQueue.

Definition at line 198 of file RemoteQueue.cc.

References ASSERT, FUNC_TRACE, CPN::ThresholdQueue::InternalEnqueue(), CPN::QueueBase::logger, mode, Signal(), and WRITE.

                                                     {
         ASSERT(mode == WRITE);
         FUNC_TRACE(logger);
         ThresholdQueue::InternalEnqueue(count);
         Signal();
     }

Here is the call graph for this function:

void CPN::RemoteQueue::InternalFlush ( )

privatevirtual

Reimplemented from CPN::QueueBase.

Definition at line 205 of file RemoteQueue.cc.

References ASSERT, CPN::QueueBase::InternalFlush(), mode, pendingFlush, Signal(), and WRITE.

                                     {
         ASSERT(mode == WRITE);
         ThresholdQueue::InternalFlush();
         pendingFlush = true;
         Signal();
     }

Here is the call graph for this function:

const void * ThresholdQueue< T >::InternalGetRawDequeuePtr	(	unsigned	thresh,
		unsigned	chan
	)

protectedvirtualinherited

Implements CPN::QueueBase.

Definition at line 126 of file CPNThresholdQueue.cc.

References ASSERT, CPN::ThresholdQueue::dequeueUseOld, ThresholdQueueBase::GetRawDequeuePtr(), CPN::QueueBase::indequeue, CPN::ThresholdQueue::oldqueue, and CPN::ThresholdQueue::queue.

Referenced by SendEnqueuePacket().

                                                                                        {
         const void *ret = 0;
         if (dequeueUseOld) {
             // The ONLY reason this code path should be followed is if the node made a getdequeueptr
             // then called getdequeueptr again before dequeue when a grow happens inbetween
             ASSERT(indequeue);
             ret = oldqueue->GetRawDequeuePtr(thresh, chan);
             ASSERT(ret);
         } else {
             ret = queue->GetRawDequeuePtr(thresh, chan);
         }
         return ret;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void * ThresholdQueue< T >::InternalGetRawEnqueuePtr	(	unsigned	thresh,
		unsigned	chan
	)

protectedvirtualinherited

Implements CPN::QueueBase.

Definition at line 57 of file CPNThresholdQueue.cc.

References ASSERT, CPN::ThresholdQueue::enqueueUseOld, ThresholdQueueBase::GetRawEnqueuePtr(), CPN::QueueBase::inenqueue, CPN::ThresholdQueue::oldqueue, and CPN::ThresholdQueue::queue.

Referenced by EnqueuePacket().

                                                                                  {
         void *ret = 0;
         if (enqueueUseOld) {
             ASSERT(inenqueue);
             ret = oldqueue->GetRawEnqueuePtr(thresh, chan);
             ASSERT(ret);
         } else {
             ret = queue->GetRawEnqueuePtr(thresh, chan);
         }
         return ret;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::RemoteQueue::InternalReset ( )

privatevirtual

Reimplemented from CPN::ThresholdQueue.

Definition at line 212 of file RemoteQueue.cc.

References ASSERT, CPN::ThresholdQueue::InternalReset(), mode, pendingReset, READ, and Signal().

                                     {
         ASSERT(mode == READ);
         ThresholdQueue::InternalReset();
         pendingReset = true;
         Signal();
     }

Here is the call graph for this function:

bool CPN::QueueBase::IsReaderShutdown ( )

inherited

Definition at line 390 of file QueueBase.cc.

References CPN::QueueBase::readshutdown.

                                      {
         AutoLock<QueueBase> al(*this);
         return readshutdown;
     }

bool CPN::QueueBase::IsWriterShutdown ( )

inherited

Definition at line 395 of file QueueBase.cc.

References CPN::QueueBase::writeshutdown.

                                      {
         AutoLock<QueueBase> al(*this);
         return writeshutdown;
     }

void CPN::QueueBase::Lock ( ) const

inlinevirtualinherited

These functions are to access the lock for the queue.

Implements D4R::QueueBase.

Definition at line 221 of file QueueBase.h.

References lock, and PthreadMutex::Lock().

221 { lock.Lock(); }

PthreadMutex::Lock

PthreadMutex & Lock(void)

Definition: PthreadMutex.h:49

CPN::QueueBase::lock

PthreadMutex lock

Definition: QueueBase.h:289

Here is the call graph for this function:

void CPN::RemoteQueue::LogState ( )

virtual

For debug ONLY!

Implements CPN::RemoteQueueBase.

Definition at line 886 of file RemoteQueue.cc.

References actionThread, CPN::BoolString(), bytecount, ClockString(), FileHandle::Closed(), dead, Logger::Error(), fileThread, CPN::QueueBase::logger, CPN::QueueBase::LogState(), mode, pendingBlock, pendingD4RTag, pendingFlush, pendingGrow, pendingReset, READ, readerlength, sentEnd, sock, and writerlength.

Referenced by InternalCheckStatus().

                                {
         ThresholdQueue::LogState();
         std::string clockstr = ClockString();
         logger.Error("Mode: %s, Readerlength: %u, Writerlength %u, Clock: %s, bytecount: %u",
                 mode == READ ? "read" : "write", readerlength, writerlength, clockstr.c_str(), bytecount);
         logger.Error("PendingBlock: %s, SentEnd: %s, PendingGrow: %s, PendingD4R: %s, Dead: %s"
                 ", PendingFlush: %s, PendingReset: %s",
                 BoolString(pendingBlock), BoolString(sentEnd), BoolString(pendingGrow),
                 BoolString(pendingD4RTag), BoolString(dead), BoolString(pendingFlush), BoolString(pendingReset));
         logger.Error("FileThread id: %llu, Running: %s, ActionThread id: %llu, Running: %s",
                 (unsigned long long)((pthread_t)(*fileThread)), BoolString(fileThread->Running()),
                 (unsigned long long)((pthread_t)(*actionThread)), BoolString(actionThread->Running()));
         if (sock.Closed()) {
             logger.Error("Socket closed");
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned CPN::QueueBase::MaxThreshold ( ) const

inherited

Returns: the maximum threshold this queue supports in bytes

Definition at line 225 of file QueueBase.cc.

References CPN::QueueBase::UnlockedMaxThreshold().

Referenced by CPN::ThresholdQueue::TQImpl::Grow(), and CPN::ThresholdQueue::UnlockedGrow().

                                            {
         AutoLock<const QueueBase> al(*this);
         return UnlockedMaxThreshold();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::QueueBase::NotifyData ( )

protectedinherited

Definition at line 341 of file QueueBase.cc.

References PthreadCondition::Broadcast(), CPN::QueueBase::cond, CPN::QueueBase::readrequest, and CPN::QueueBase::UnlockedCount().

Referenced by CPN::QueueBase::Enqueue(), and EnqueuePacket().

                                {
         if (UnlockedCount() >= readrequest) {
             cond.Broadcast();
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::QueueBase::NotifyFreespace ( )

protectedinherited

Definition at line 362 of file QueueBase.cc.

References PthreadCondition::Broadcast(), CPN::QueueBase::cond, CPN::QueueBase::UnlockedFreespace(), and CPN::QueueBase::writerequest.

Referenced by CPN::QueueBase::Dequeue(), and SendEnqueuePacket().

                                     {
         if (UnlockedFreespace() >= writerequest) {
             cond.Broadcast();
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::QueueBase::NotifyTerminate ( )

inherited

Used to tell any waiting threads that the network is terminating.

Definition at line 368 of file QueueBase.cc.

References PthreadCondition::Broadcast(), and CPN::QueueBase::cond.

                                     {
         AutoLock<QueueBase> al(*this);
         cond.Broadcast();
     }

Here is the call graph for this function:

unsigned CPN::PacketDecoder::NumBytes ( ) const

inlineinherited

Definition at line 48 of file PacketDecoder.h.

48 { return numbytes; }

CPN::PacketDecoder::numbytes

unsigned numbytes

Definition: PacketDecoder.h:53

unsigned CPN::QueueBase::NumChannels ( ) const

inherited

Returns: the number of channels supported by this queue.

Definition at line 200 of file QueueBase.cc.

References CPN::QueueBase::UnlockedNumChannels().

                                           {
         AutoLock<const QueueBase> al(*this);
         return UnlockedNumChannels();
     }

Here is the call graph for this function:

unsigned CPN::QueueBase::NumDequeued ( ) const

inherited

Definition at line 321 of file QueueBase.cc.

References CPN::QueueBase::UnlockedNumDequeued().

                                           {
         AutoLock<const QueueBase> al(*this);
         return UnlockedNumDequeued();
     }

Here is the call graph for this function:

unsigned CPN::QueueBase::NumEnqueued ( ) const

inherited

Definition at line 316 of file QueueBase.cc.

References CPN::QueueBase::UnlockedNumEnqueued().

                                           {
         AutoLock<const QueueBase> al(*this);
         return UnlockedNumEnqueued();
     }

Here is the call graph for this function:

unsigned CPN::RemoteQueue::QueueLength	(	unsigned	length,
		unsigned	maxthresh,
		double	alpha,
		Mode_t	mode
	)

staticprivate

Definition at line 850 of file RemoteQueue.cc.

References READ.

                                                                                                     {
         unsigned writerlen = unsigned(((double)length)*alpha);
         if (mode == READ) {
             return std::max<unsigned>(length - writerlen, maxthresh);
         } else {
             return std::max<unsigned>(writerlen, maxthresh);
         }
     }

unsigned CPN::QueueBase::QueueLength ( ) const

inherited

Returns: the maximum number of bytes that can be put in this queue.

Definition at line 230 of file QueueBase.cc.

References CPN::QueueBase::UnlockedQueueLength().

Referenced by CPN::ThresholdQueue::TQImpl::Grow(), GrowPacket(), CPN::ThresholdQueue::UnlockedGrow(), and UnlockedGrow().

                                           {
         AutoLock<const QueueBase> al(*this);
         return UnlockedQueueLength();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

bool CPN::QueueBase::RawDequeue	(	void *	data,
		unsigned	count,
		unsigned	numChans,
		unsigned	chanStride
	)

inherited

Dequeue data from the queue directly into the memory pointed to by data. This function shall be equivalent to a call to GetRawDequeuePtr then a memcpy and then a call to Dequeue.

Parameters

data	poiner to memory to dequeue to
count	the number of bytes to copy into data
numChans	the number of channels to write to
chanStride	the distance in bytes between the beginning of the channels in data.

Returns: true on success false on failure

Definition at line 102 of file QueueBase.cc.

References ASSERT, CPN::QueueBase::Dequeue(), and CPN::QueueBase::GetRawDequeuePtr().

Referenced by CPN::QueueBase::RawDequeue().

                                                                                                  {
         const void *src = GetRawDequeuePtr(count, 0);
         char *dest = (char*)data;
         if (!src) { return false; }
         memcpy(dest, src, count);
         for (unsigned chan = 1; chan < numChans; ++chan) {
             src = GetRawDequeuePtr(count, chan);
             ASSERT(src);
             dest += chanStride;
             memcpy(dest, src, count);
         }
         Dequeue(count);
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

bool CPN::QueueBase::RawDequeue	(	void *	data,
		unsigned	count
	)

inherited

A version of RawDequeue to use when there is only 1 channel.

Parameters

data	the data to enqueue
count	the number of bytes to enqueue

Returns: true on success false if we have reached the end of the queue

Definition at line 117 of file QueueBase.cc.

References CPN::QueueBase::RawDequeue().

                                                          {
         return RawDequeue(data, count, 1, 0);
     }

Here is the call graph for this function:

void CPN::QueueBase::RawEnqueue	(	const void *	data,
		unsigned	count,
		unsigned	numChans,
		unsigned	chanStride
	)

inherited

This function shall be equivalent to a call to GetRqwEnqueuePtr and a memcpy and then a call to Enqueue

The underlying implementatin may implement ether the GetRawEnqueuePtr and Enqueue or RawEnqueue and then implement the other in terms of the one implemented.

Parameters

data	pointer to the memory to enqueue
count	the number of bytes to enqueue
numChans	the number of channels to write to
chanStride	the distance in bytes between the beginning of the channels in data.

Definition at line 169 of file QueueBase.cc.

References CPN::QueueBase::Enqueue(), and CPN::QueueBase::GetRawEnqueuePtr().

Referenced by CPN::QueueBase::RawEnqueue().

                                                                                                        {
         void *dest = GetRawEnqueuePtr(count, 0);
         const char *src = (char*)data;
         memcpy(dest, src, count);
         for (unsigned chan = 1; chan < numChans; ++chan) {
             dest = GetRawEnqueuePtr(count, chan);
             src += chanStride;
             memcpy(dest, src, count);
         }
         Enqueue(count);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::QueueBase::RawEnqueue	(	const void *	data,
		unsigned	count
	)

inherited

A version of RawEnqueue to use when there is only 1 channel.

Parameters

data	pointer to the memory to enqueue
count	the number of bytes to enqueue

Definition at line 196 of file QueueBase.cc.

References CPN::QueueBase::RawEnqueue().

                                                                {
         return RawEnqueue(data, count, 1, 0);
     }

Here is the call graph for this function:

void CPN::RemoteQueue::Read ( )

private

Definition at line 540 of file RemoteQueue.cc.

References Logger::Debug(), FileHandle::Eof(), CPN::PacketDecoder::GetDecoderBytes(), CPN::QueueBase::logger, FileHandle::Readable(), SocketHandle::Recv(), CPN::PacketDecoder::ReleaseDecoderBytes(), and sock.

Referenced by InternalCheckStatus().

                            {
         while (sock.Readable()) {
             unsigned numtoread = 0;
             void *ptr = PacketDecoder::GetDecoderBytes(numtoread);
             unsigned numread = sock.Recv(ptr, numtoread, false);
             if (numread == 0) {
                 if (sock.Eof()) {
                     logger.Debug("Read EOF");
                 }
                 break;
             } else {
                 PacketDecoder::ReleaseDecoderBytes(numread);
             }
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void D4R::QueueBase::ReadBlock ( )

protectedinherited

reader ===> writer ReadBlock requires that you already hold the lock and if it is reentrant then a single unlock will release the lock.

Exceptions

D4R::DeadlockException

Definition at line 71 of file D4RQueue.cc.

References D4R::QueueBase::incomm, D4R::QueueBase::ReadBlocked(), D4R::QueueBase::reader, D4R::QueueBase::Signal(), D4R::QueueBase::Wait(), D4R::QueueBase::writer, and D4R::QueueBase::writetagchanged.

Referenced by CPN::QueueBase::WaitForData().

                               {
         if (!writer) {
             while (ReadBlocked() && !writer) {
                 Wait();
             }
         }
         if (!ReadBlocked()) { return; }
         writetagchanged = false;
         try {
             while (incomm) { Wait(); }
             ScopeSetter<bool> ss(incomm, true);
             AutoUnlock<QueueBase> au(*this);
             reader->Block(writer->GetPublicTag(), -1);
         } catch (...) { Signal(); throw; }
         Signal();
         while (ReadBlocked()) {
             if (writetagchanged) {
                 writetagchanged = false;
                 bool detect;
                 try {
                     while (incomm) { Wait(); }
                     ScopeSetter<bool> ss(incomm, true);
                     AutoUnlock<QueueBase> au(*this);
                     detect = reader->Transmit(writer->GetPublicTag());
                 } catch (...) { Signal(); throw; }
                 Signal();
                 if (detect) {
                     throw DeadlockException("True deadlock detected");
                 }
             } else {
                 Wait();
             }
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

bool CPN::QueueBase::ReadBlocked ( )

protectedvirtualinherited

Returns: true if we are blocked

Implements D4R::QueueBase.

Definition at line 336 of file QueueBase.cc.

References CPN::KernelBase::CheckTerminated(), CPN::QueueBase::flushed, CPN::QueueBase::kernel, CPN::QueueBase::readrequest, CPN::QueueBase::readshutdown, CPN::QueueBase::UnlockedCount(), and CPN::QueueBase::writeshutdown.

Referenced by CPN::QueueBase::GetRawEnqueuePtr(), WaitForData(), and CPN::QueueBase::WaitForData().

                                 {
         kernel->CheckTerminated();
         return UnlockedCount() < readrequest && !(readshutdown || writeshutdown) && !flushed;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::RemoteQueue::ReadBlockPacket ( const Packet & packet )

privatevirtual

Implements CPN::PacketHandler.

Definition at line 354 of file RemoteQueue.cc.

References ASSERT, bytecount, ThresholdQueueBase::Count(), FUNC_TRACE, CPN::QueueBase::logger, mode, pendingD4RTag, CPN::ThresholdQueue::queue, CPN::QueueBase::readrequest, CPN::QueueBase::readshutdown, CPN::Packet::Requested(), UpdateClock(), CPN::QueueBase::useD4R, and WRITE.

                                                           {
         UpdateClock(packet);
         FUNC_TRACE(logger);
         ASSERT(mode == WRITE);
         ASSERT(!readshutdown);
         readrequest = packet.Requested();
         if (readrequest > queue->Count() + bytecount) {
             if (useD4R) {
                 pendingD4RTag = true;
             }
         }
     }

Here is the call graph for this function:

unsigned CPN::QueueBase::ReadRequest ( )

inherited

For unit tests.

Definition at line 380 of file QueueBase.cc.

References CPN::QueueBase::readrequest.

                                     {
         AutoLock<QueueBase> al(*this);
         return readrequest;
     }

void CPN::PacketDecoder::ReleaseDecoderBytes ( unsigned amount )

inherited

Definition at line 44 of file PacketDecoder.cc.

References ASSERT, CPN::PacketHandler::FirePacket(), CPN::PacketDecoder::header, CPN::Packet::header, CPN::PacketDecoder::numbytes, and CPN::Packet::Valid().

Referenced by Read().

                                                            {
         ASSERT(numbytes + amount <= sizeof(header.header));
         numbytes += amount;
         if (numbytes == sizeof(header.header)) {
             if (header.Valid()) {
                 FirePacket(header);
                 numbytes = 0;
             } else {
                 // If it is not valid, what do we do??
                 // Well, we can search for the header word
                 // wont always work...
                 char *ptr = reinterpret_cast<char*>(&header.header);
                 numbytes -= 1;
                 memmove(ptr, ptr + 1, numbytes);
             }
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::PacketDecoder::Reset ( )

inherited

Definition at line 62 of file PacketDecoder.cc.

References CPN::PacketDecoder::numbytes.

                               {
         numbytes = 0;
     }

void CPN::QueueBase::Reset ( )

inherited

Definition at line 181 of file QueueBase.cc.

References CPN::QueueBase::InternalReset().

                           {
         AutoLock<const QueueBase> al(*this);
         InternalReset();
     }

Here is the call graph for this function:

void CPN::RemoteQueue::ResetPacket ( const Packet & packet )

privatevirtual

Implements CPN::PacketHandler.

Definition at line 504 of file RemoteQueue.cc.

References CPN::QueueBase::dequeuethresh, CPN::ThresholdQueue::dequeueUseOld, CPN::QueueBase::enqueuethresh, CPN::ThresholdQueue::enqueueUseOld, CPN::QueueBase::flushed, FUNC_TRACE, CPN::QueueBase::indequeue, CPN::QueueBase::inenqueue, CPN::QueueBase::logger, CPN::ThresholdQueue::oldqueue, CPN::ThresholdQueue::queue, CPN::QueueBase::readrequest, ThresholdQueueBase::Reset(), Signal(), UpdateClock(), and CPN::QueueBase::writerequest.

                                                       {
         UpdateClock(packet);
         FUNC_TRACE(logger);
         if (dequeueUseOld || enqueueUseOld) {
             dequeueUseOld = false;
             enqueueUseOld = false;
             delete oldqueue;
             oldqueue = 0;
         }
         queue->Reset();
         readrequest = 0;
         writerequest = 0;
         enqueuethresh = 0;
         dequeuethresh = 0;
         indequeue = false;
         inenqueue = false;
         flushed = false;
         Signal();
     }

Here is the call graph for this function:

void CPN::RemoteQueue::SendD4RTagPacket ( )

private

Definition at line 475 of file RemoteQueue.cc.

References CPN::Packet::DataLength(), FUNC_TRACE, CPN::QueueBase::logger, mode, CPN::PACKET_D4RTAG, READ, D4R::QueueBase::reader, CPN::PacketEncoder::SendPacket(), SetupPacket(), and D4R::QueueBase::writer.

Referenced by InternalCheckStatus().

                                        {
         FUNC_TRACE(logger);
         Packet packet(PACKET_D4RTAG);
         SetupPacket(packet);
         packet.DataLength(sizeof(D4R::Tag));
         D4R::Tag tag;
         if (mode == READ) {
             tag = reader->GetPublicTag();
         } else {
             tag = writer->GetPublicTag();
         }
         PacketEncoder::SendPacket(packet, &tag);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::RemoteQueue::SendDequeuePacket ( )

private

Definition at line 344 of file RemoteQueue.cc.

References bytecount, ThresholdQueueBase::Count(), CPN::Packet::Count(), FUNC_TRACE, CPN::QueueBase::logger, CPN::PACKET_DEQUEUE, CPN::ThresholdQueue::queue, CPN::PacketEncoder::SendPacket(), and SetupPacket().

Referenced by InternalCheckStatus().

                                         {
         FUNC_TRACE(logger);
         Packet packet(PACKET_DEQUEUE);
         SetupPacket(packet);
         const unsigned count = bytecount - queue->Count();
         packet.Count(count);
         PacketEncoder::SendPacket(packet);
         bytecount -= count;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::RemoteQueue::SendEndOfReadPacket ( )

private

Definition at line 425 of file RemoteQueue.cc.

References ASSERT, Logger::Debug(), FUNC_TRACE, CPN::QueueBase::logger, CPN::PACKET_ENDOFREAD, CPN::PacketEncoder::SendPacket(), sentEnd, SetupPacket(), SocketHandle::ShutdownWrite(), sock, and ErrnoException::what().

Referenced by InternalCheckStatus().

                                           {
         FUNC_TRACE(logger);
         ASSERT(!sentEnd);
         Packet packet(PACKET_ENDOFREAD);
         SetupPacket(packet);
         PacketEncoder::SendPacket(packet);
         try {
             sock.ShutdownWrite();
         } catch (const ErrnoException &e) {
             logger.Debug("Error trying to close the read end: %s", e.what());
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::RemoteQueue::SendEndOfWritePacket ( )

private

Definition at line 404 of file RemoteQueue.cc.

References ASSERT, Logger::Debug(), FUNC_TRACE, CPN::QueueBase::logger, CPN::PACKET_ENDOFWRITE, CPN::PacketEncoder::SendPacket(), sentEnd, SetupPacket(), SocketHandle::ShutdownWrite(), sock, and ErrnoException::what().

Referenced by InternalCheckStatus().

                                            {
         FUNC_TRACE(logger);
         ASSERT(!sentEnd);
         Packet packet(PACKET_ENDOFWRITE);
         SetupPacket(packet);
         PacketEncoder::SendPacket(packet);
         try {
             sock.ShutdownWrite();
         } catch (const ErrnoException &e) {
             logger.Debug("Error trying to close the write end: %s", e.what());
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename Queue_t >

void CPN::PacketEncoder::SendEnqueue	(	const Packet &	packet,
		Queue_t &	queue
	)

inlineinherited

Definition at line 44 of file PacketEncoder.h.

References ASSERT, CPN::Packet::Count(), CPN::Packet::header, CPN::PACKET_ENQUEUE, and CPN::Packet::Type().

                                                                {
             ASSERT(packet.Type() == PACKET_ENQUEUE);
             std::vector<iovec> iovs;
             // Must use const_cast here because iovec.iov_base isn't const... :(
             iovec header = { const_cast<PacketHeader*>(&packet.header), sizeof(packet.header) };
             iovs.push_back(header);
             for (unsigned i = 0; i < queue.NumChannels(); ++i) {
                 iovec iov;
                 iov.iov_base = const_cast<void*>(queue.GetRawDequeuePtr(packet.Count(), i));
                 ASSERT(iov.iov_base);
                 iov.iov_len = packet.Count();
                 iovs.push_back(iov);
             }
             WriteBytes(&iovs[0], iovs.size());
             queue.Dequeue(packet.Count());
         }

Here is the call graph for this function:

void CPN::RemoteQueue::SendEnqueuePacket ( )

private

Definition at line 294 of file RemoteQueue.cc.

References ASSERT, bytecount, ThresholdQueueBase::Count(), CPN::Packet::Count(), FUNC_TRACE, CPN::PacketDecoder::header, CPN::Packet::header, CPN::QueueBase::indequeue, CPN::ThresholdQueue::InternalDequeue(), CPN::ThresholdQueue::InternalGetRawDequeuePtr(), CPN::QueueBase::logger, ThresholdQueueBase::MaxThreshold(), maxwritethreshold, CPN::QueueBase::NotifyFreespace(), ThresholdQueueBase::NumChannels(), CPN::PACKET_ENQUEUE, CPN::ThresholdQueue::queue, readerlength, SetupPacket(), and WriteBytes().

Referenced by InternalCheckStatus().

                                         {
         unsigned count = queue->Count();
         const unsigned numchannels = queue->NumChannels();
         const unsigned maxthresh = queue->MaxThreshold();
         const unsigned expectedfree = std::max(readerlength, maxthresh) - bytecount;
         if (maxwritethreshold > 0) {
             unsigned maxwrite = maxwritethreshold/numchannels;
             if (maxwrite == 0) maxwrite = 1;
             if (count > maxwrite) { count = maxwrite; }
         }
         if (count > maxthresh) { count = maxthresh; }
         if (count > expectedfree) { count = expectedfree; }
         if (count == 0) { return; }
         FUNC_TRACE(logger);
         const unsigned datalength = count * numchannels;
         Packet packet(datalength, PACKET_ENQUEUE);
         SetupPacket(packet);
         packet.Count(count);
 
         std::vector<iovec> iovs;
         iovec header = { &packet.header, sizeof(packet.header) };
         iovs.push_back(header);
         for (unsigned i = 0; i < numchannels; ++i) {
             iovec iov;
             iov.iov_base = const_cast<void*>(ThresholdQueue::InternalGetRawDequeuePtr(packet.Count(), i));
             ASSERT(iov.iov_base);
             iov.iov_len = packet.Count();
             iovs.push_back(iov);
         }
         indequeue = true;
         {
             AutoUnlock<QueueBase> aul(*this);
             WriteBytes(&iovs[0], iovs.size());
         }
         indequeue = false;
         ThresholdQueue::InternalDequeue(packet.Count());
 
         bytecount += count;
         QueueBase::NotifyFreespace();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::RemoteQueue::SendFlushPacket ( )

private

Definition at line 496 of file RemoteQueue.cc.

References FUNC_TRACE, CPN::QueueBase::logger, CPN::PACKET_FLUSH, pendingFlush, CPN::PacketEncoder::SendPacket(), and SetupPacket().

Referenced by InternalCheckStatus().

                                       {
         FUNC_TRACE(logger);
         Packet packet(PACKET_FLUSH);
         SetupPacket(packet);
         PacketEncoder::SendPacket(packet);
         pendingFlush = false;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::RemoteQueue::SendGrowPacket ( )

private

Definition at line 449 of file RemoteQueue.cc.

References FUNC_TRACE, CPN::QueueBase::logger, ThresholdQueueBase::MaxThreshold(), CPN::Packet::MaxThreshold(), CPN::PACKET_GROW, CPN::ThresholdQueue::queue, CPN::Packet::QueueSize(), readerlength, CPN::PacketEncoder::SendPacket(), SetupPacket(), and writerlength.

Referenced by InternalCheckStatus().

                                      {
         FUNC_TRACE(logger);
         Packet packet(PACKET_GROW);
         SetupPacket(packet);
         packet.QueueSize(readerlength + writerlength);
         packet.MaxThreshold(queue->MaxThreshold());
         PacketEncoder::SendPacket(packet);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::PacketEncoder::SendPacket ( const Packet & packet )

inherited

Definition at line 32 of file PacketEncoder.cc.

References CPN::Packet::header, and CPN::PacketEncoder::WriteBytes().

Referenced by SendD4RTagPacket(), SendDequeuePacket(), SendEndOfReadPacket(), SendEndOfWritePacket(), SendFlushPacket(), SendGrowPacket(), SendReadBlockPacket(), SendResetPacket(), and SendWriteBlockPacket().

                                                        {
         iovec iov;
         iov.iov_base = const_cast<PacketHeader*>(&packet.header);
         iov.iov_len = sizeof(packet.header);
         WriteBytes(&iov, 1);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::PacketEncoder::SendPacket	(	const Packet &	packet,
		void *	data
	)

inherited

Definition at line 39 of file PacketEncoder.cc.

References ASSERT, CPN::Packet::DataLength(), CPN::Packet::header, and CPN::PacketEncoder::WriteBytes().

                                                                    {
         ASSERT(data);
         iovec iov[2];
         iov[0].iov_base = const_cast<PacketHeader*>(&packet.header);
         iov[0].iov_len = sizeof(packet.header);
         iov[1].iov_base = data;
         iov[1].iov_len = packet.DataLength();
         WriteBytes(&iov[0], 2);
     }

Here is the call graph for this function:

void CPN::RemoteQueue::SendReadBlockPacket ( )

private

Definition at line 367 of file RemoteQueue.cc.

References FUNC_TRACE, CPN::QueueBase::logger, CPN::PACKET_READBLOCK, CPN::QueueBase::readrequest, CPN::Packet::Requested(), CPN::PacketEncoder::SendPacket(), and SetupPacket().

Referenced by InternalCheckStatus().

                                           {
         FUNC_TRACE(logger);
         Packet packet(PACKET_READBLOCK);
         SetupPacket(packet);
         packet.Requested(readrequest);
         PacketEncoder::SendPacket(packet);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::RemoteQueue::SendResetPacket ( )

private

Definition at line 524 of file RemoteQueue.cc.

References FUNC_TRACE, CPN::QueueBase::logger, CPN::PACKET_RESET, pendingReset, CPN::PacketEncoder::SendPacket(), and SetupPacket().

Referenced by InternalCheckStatus().

                                       {
         FUNC_TRACE(logger);
         Packet packet(PACKET_RESET);
         SetupPacket(packet);
         PacketEncoder::SendPacket(packet);
         pendingReset = false;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::RemoteQueue::SendWriteBlockPacket ( )

private

Definition at line 388 of file RemoteQueue.cc.

References FUNC_TRACE, CPN::QueueBase::logger, CPN::PACKET_WRITEBLOCK, CPN::Packet::Requested(), CPN::PacketEncoder::SendPacket(), SetupPacket(), and CPN::QueueBase::writerequest.

Referenced by InternalCheckStatus().

                                            {
         FUNC_TRACE(logger);
         Packet packet(PACKET_WRITEBLOCK);
         SetupPacket(packet);
         packet.Requested(writerequest);
         PacketEncoder::SendPacket(packet);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void D4R::QueueBase::SetReaderNode ( shared_ptr< Node > n )

inherited

Set the node which is reading from this queue

Parameters

n the node

Definition at line 59 of file D4RQueue.cc.

References D4R::QueueBase::reader, and D4R::QueueBase::Signal().

Referenced by RemoteQueue().

                                                     {
         AutoLock<QueueBase> al(*this);
         reader = n;
         Signal();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::RemoteQueue::SetupPacket ( Packet & packet )

private

Definition at line 233 of file RemoteQueue.cc.

References clock, mode, READ, CPN::Packet::ReadClock(), readclock, TickClock(), and writeclock.

Referenced by SendD4RTagPacket(), SendDequeuePacket(), SendEndOfReadPacket(), SendEndOfWritePacket(), SendEnqueuePacket(), SendFlushPacket(), SendGrowPacket(), SendReadBlockPacket(), SendResetPacket(), and SendWriteBlockPacket().

                                                 {
         TickClock();
         if (mode == READ) {
             packet.ReadClock(clock).WriteClock(writeclock);
         } else {
             packet.ReadClock(readclock).WriteClock(clock);
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void D4R::QueueBase::SetWriterNode ( shared_ptr< Node > n )

inherited

Set the node which is writing to this queue.

Parameters

n the node

Definition at line 65 of file D4RQueue.cc.

References D4R::QueueBase::Signal(), and D4R::QueueBase::writer.

Referenced by RemoteQueue().

                                                     {
         AutoLock<QueueBase> al(*this);
         writer = n;
         Signal();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::RemoteQueue::Shutdown ( )

virtual

Tell the queue that CPN is shutting down and the queue should start cleaning up.

Implements CPN::RemoteQueueBase.

Definition at line 113 of file RemoteQueue.cc.

References UnlockedShutdown().

Referenced by FileThreadEntryPoint().

                                {
         AutoLock<const QueueBase> al(*this);
         UnlockedShutdown();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::QueueBase::ShutdownReader ( )

inherited

Called by the QueueReader when no more data will be read.

Definition at line 250 of file QueueBase.cc.

References CPN::QueueBase::UnlockedShutdownReader().

Referenced by FileThreadEntryPoint().

                                    {
         AutoLock<QueueBase> al(*this);
         UnlockedShutdownReader();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::QueueBase::ShutdownWriter ( )

inherited

Called by the QueueWriter when no more data will be written.

Definition at line 260 of file QueueBase.cc.

References CPN::QueueBase::UnlockedShutdownWriter().

Referenced by FileThreadEntryPoint().

                                    {
         AutoLock<QueueBase> al(*this);
         UnlockedShutdownWriter();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::RemoteQueue::Signal ( )

privatevirtual

Signal that Wait should return

Reimplemented from CPN::QueueBase.

Definition at line 657 of file RemoteQueue.cc.

References pendingAction, and CPN::QueueBase::Signal().

Referenced by D4RTagPacket(), FileThreadEntryPoint(), FlushPacket(), HandleError(), InternalDequeue(), InternalEnqueue(), InternalFlush(), InternalReset(), ResetPacket(), UnlockedGrow(), UnlockedShutdown(), WaitForData(), WaitForFreespace(), and ~RemoteQueue().

                              {
         pendingAction = true;
         QueueBase::Signal();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void D4R::QueueBase::SignalReaderTagChanged ( )

inherited

These functions are called by the D4R::Node when thier tag changes.

Definition at line 139 of file D4RQueue.cc.

References D4R::QueueBase::UnlockedSignalReaderTagChanged().

                                            {
         AutoLock<QueueBase> al(*this);
         UnlockedSignalReaderTagChanged();
     }

Here is the call graph for this function:

void D4R::QueueBase::SignalWriterTagChanged ( )

inherited

Definition at line 150 of file D4RQueue.cc.

References D4R::QueueBase::UnlockedSignalWriterTagChanged().

                                            {
         AutoLock<QueueBase> al(*this);
         UnlockedSignalWriterTagChanged();
     }

Here is the call graph for this function:

void CPN::RemoteQueue::Start ( void )

virtual

Start the internals of this queue.

Implements CPN::RemoteQueueBase.

Definition at line 109 of file RemoteQueue.cc.

References fileThread.

                             {
         fileThread->Start();
     }

void CPN::RemoteQueue::TickClock ( )

private

Definition at line 815 of file RemoteQueue.cc.

References clock.

Referenced by SetupPacket().

                                 {
         ++clock;
     }

Here is the caller graph for this function:

void CPN::QueueBase::Unlock ( void ) const

inlinevirtualinherited

Implements D4R::QueueBase.

Definition at line 222 of file QueueBase.h.

References lock, and PthreadMutex::Unlock().

222 { lock.Unlock(); }

PthreadMutex::Unlock

PthreadMutex & Unlock(void)

Definition: PthreadMutex.h:50

CPN::QueueBase::lock

PthreadMutex lock

Definition: QueueBase.h:289

Here is the call graph for this function:

unsigned CPN::RemoteQueue::UnlockedCount ( ) const

privatevirtual

Reimplemented from CPN::ThresholdQueue.

Definition at line 125 of file RemoteQueue.cc.

References bytecount, ThresholdQueueBase::Count(), mode, CPN::ThresholdQueue::queue, and READ.

Referenced by GetState().

                                               {
         if (mode == READ) {
             return queue->Count();
         } else {
             return queue->Count() + bytecount;
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned ThresholdQueue< T >::UnlockedDequeueChannelStride ( ) const

protectedvirtualinherited

Implements CPN::QueueBase.

Definition at line 110 of file CPNThresholdQueue.cc.

References ThresholdQueueBase::ChannelStride(), CPN::ThresholdQueue::dequeueUseOld, CPN::ThresholdQueue::oldqueue, and CPN::ThresholdQueue::queue.

                                                                 {
         if (dequeueUseOld) {
             return oldqueue->ChannelStride();
         } else {
             return queue->ChannelStride();
         }
     }

Here is the call graph for this function:

bool CPN::RemoteQueue::UnlockedEmpty ( ) const

privatevirtual

Reimplemented from CPN::ThresholdQueue.

Definition at line 133 of file RemoteQueue.cc.

References bytecount, ThresholdQueueBase::Empty(), mode, CPN::ThresholdQueue::queue, and READ.

                                           {
         if (mode == READ) {
             return queue->Empty();
         } else {
             return queue->Empty() && (bytecount == 0);
         }
     }

Here is the call graph for this function:

unsigned ThresholdQueue< T >::UnlockedEnqueueChannelStride ( ) const

protectedvirtualinherited

Implements CPN::QueueBase.

Definition at line 102 of file CPNThresholdQueue.cc.

References ThresholdQueueBase::ChannelStride(), CPN::ThresholdQueue::enqueueUseOld, CPN::ThresholdQueue::oldqueue, and CPN::ThresholdQueue::queue.

                                                                 {
         if (enqueueUseOld) {
             return oldqueue->ChannelStride();
         } else {
             return queue->ChannelStride();
         }
     }

Here is the call graph for this function:

unsigned ThresholdQueue< T >::UnlockedFreespace ( ) const

protectedvirtualinherited

Implements CPN::QueueBase.

Definition at line 118 of file CPNThresholdQueue.cc.

References ThresholdQueueBase::Freespace(), and CPN::ThresholdQueue::queue.

Referenced by GetState().

                                                      {
         return queue->Freespace();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

bool ThresholdQueue< T >::UnlockedFull ( ) const

protectedvirtualinherited

Implements CPN::QueueBase.

Definition at line 122 of file CPNThresholdQueue.cc.

References ThresholdQueueBase::Full(), and CPN::ThresholdQueue::queue.

                                             {
         return queue->Full();
     }

Here is the call graph for this function:

void CPN::RemoteQueue::UnlockedGrow	(	unsigned	queueLen,
		unsigned	maxThresh
	)

privatevirtual

Reimplemented from CPN::ThresholdQueue.

Definition at line 145 of file RemoteQueue.cc.

References actionCond, alpha, dead, FUNC_TRACE, CPN::QueueBase::lock, CPN::QueueBase::logger, ThresholdQueueBase::MaxThreshold(), mode, pendingGrow, CPN::ThresholdQueue::queue, CPN::QueueBase::QueueLength(), READ, readerlength, Signal(), CPN::ThresholdQueue::UnlockedGrow(), CPN::ThresholdQueue::UnlockedMaxThreshold(), UnlockedQueueLength(), PthreadCondition::Wait(), WRITE, and writerlength.

                                                                         {
         FUNC_TRACE(logger);
         if (queueLen <= UnlockedQueueLength() && maxThresh <= UnlockedMaxThreshold()) return;
         while (pendingGrow && !dead) {
             Signal();
             actionCond.Wait(lock);
         }
         const unsigned maxthresh = std::max<unsigned>(queue->MaxThreshold(), maxThresh);
         readerlength = QueueLength(queueLen, maxthresh, alpha, READ);
         writerlength = QueueLength(queueLen, maxthresh, alpha, WRITE);
         const unsigned newlen = (mode == WRITE ? writerlength : readerlength);
         ThresholdQueue::UnlockedGrow(newlen, maxthresh);
         pendingGrow = true;
         Signal();
     }

Here is the call graph for this function:

unsigned ThresholdQueue< T >::UnlockedMaxThreshold ( ) const

protectedvirtualinherited

Implements CPN::QueueBase.

Definition at line 157 of file CPNThresholdQueue.cc.

References ThresholdQueueBase::MaxThreshold(), and CPN::ThresholdQueue::queue.

Referenced by GetState(), and UnlockedGrow().

                                                         {
         return queue->MaxThreshold();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned ThresholdQueue< T >::UnlockedNumChannels ( ) const

protectedvirtualinherited

Implements CPN::QueueBase.

Definition at line 98 of file CPNThresholdQueue.cc.

References ThresholdQueueBase::NumChannels(), and CPN::ThresholdQueue::queue.

                                                        {
         return queue->NumChannels();
     }

Here is the call graph for this function:

unsigned ThresholdQueue< T >::UnlockedNumDequeued ( ) const

protectedvirtualinherited

Implements CPN::QueueBase.

Definition at line 169 of file CPNThresholdQueue.cc.

References ThresholdQueueBase::ElementsDequeued(), and CPN::ThresholdQueue::queue.

Referenced by GetState().

                                                        {
         return queue->ElementsDequeued();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned ThresholdQueue< T >::UnlockedNumEnqueued ( ) const

protectedvirtualinherited

Implements CPN::QueueBase.

Definition at line 165 of file CPNThresholdQueue.cc.

References ThresholdQueueBase::ElementsEnqueued(), and CPN::ThresholdQueue::queue.

Referenced by GetState().

                                                        {
         return queue->ElementsEnqueued();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned CPN::RemoteQueue::UnlockedQueueLength ( ) const

privatevirtual

Reimplemented from CPN::ThresholdQueue.

Definition at line 141 of file RemoteQueue.cc.

References readerlength, and writerlength.

Referenced by GetState(), and UnlockedGrow().

                                                     {
         return readerlength + writerlength;
     }

Here is the caller graph for this function:

void CPN::RemoteQueue::UnlockedShutdown ( )

private

Definition at line 118 of file RemoteQueue.cc.

References actionCond, PthreadCondition::Broadcast(), dead, FUNC_TRACE, CPN::QueueBase::logger, and Signal().

Referenced by InternalCheckStatus(), and Shutdown().

                                        {
         FUNC_TRACE(logger);
         dead = true;
         actionCond.Broadcast();
         Signal();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::QueueBase::UnlockedShutdownReader ( )

protectedvirtualinherited

Definition at line 255 of file QueueBase.cc.

References CPN::QueueBase::readshutdown, and CPN::QueueBase::Signal().

Referenced by EndOfReadPacket(), InternalCheckStatus(), and CPN::QueueBase::ShutdownReader().

                                            {
         readshutdown = true;
         Signal();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::QueueBase::UnlockedShutdownWriter ( )

protectedvirtualinherited

Definition at line 311 of file QueueBase.cc.

References CPN::QueueBase::Signal(), and CPN::QueueBase::writeshutdown.

Referenced by EndOfWritePacket(), InternalCheckStatus(), and CPN::QueueBase::ShutdownWriter().

                                            {
         writeshutdown = true;
         Signal();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::RemoteQueue::UnlockedSignalReaderTagChanged ( )

privatevirtual

Reimplemented from D4R::QueueBase.

Definition at line 219 of file RemoteQueue.cc.

References ASSERT, FUNC_TRACE, CPN::QueueBase::logger, mode, pendingD4RTag, READ, and D4R::QueueBase::UnlockedSignalReaderTagChanged().

                                                      {
         FUNC_TRACE(logger);
         ASSERT(mode == READ);
         pendingD4RTag = true;
         ThresholdQueue::UnlockedSignalReaderTagChanged();
     }

Here is the call graph for this function:

void CPN::RemoteQueue::UnlockedSignalWriterTagChanged ( )

privatevirtual

Reimplemented from D4R::QueueBase.

Definition at line 226 of file RemoteQueue.cc.

References ASSERT, FUNC_TRACE, CPN::QueueBase::logger, mode, pendingD4RTag, D4R::QueueBase::UnlockedSignalWriterTagChanged(), and WRITE.

                                                      {
         FUNC_TRACE(logger);
         ASSERT(mode == WRITE);
         pendingD4RTag = true;
         ThresholdQueue::UnlockedSignalWriterTagChanged();
     }

Here is the call graph for this function:

void CPN::RemoteQueue::UpdateClock ( const Packet & packet )

private

Definition at line 805 of file RemoteQueue.cc.

References clock, mode, READ, CPN::Packet::ReadClock(), readclock, CPN::Packet::WriteClock(), and writeclock.

Referenced by D4RTagPacket(), DequeuePacket(), EndOfReadPacket(), EndOfWritePacket(), EnqueuePacket(), FlushPacket(), GrowPacket(), ReadBlockPacket(), ResetPacket(), and WriteBlockPacket().

                                                       {
         writeclock = packet.WriteClock();
         readclock = packet.ReadClock();
         if (mode == READ) {
             clock = std::max(writeclock, clock) + 1;
         } else {
             clock = std::max(readclock, clock) + 1;
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void CPN::QueueBase::Wait ( )

inlineprotectedvirtualinherited

Wait untill Signal is called. Must be holding the lock to call.

Implements D4R::QueueBase.

Definition at line 246 of file QueueBase.h.

References lock.

Referenced by ActionThreadEntryPoint(), CPN::QueueBase::GetRawEnqueuePtr(), WaitForData(), and WaitForFreespace().

246 { cond.Wait(lock); }

PthreadCondition::Wait

PthreadCondition & Wait(PthreadMutex &mutex)

Definition: PthreadCondition.cc:84

CPN::QueueBase::cond

PthreadCondition cond

Definition: QueueBase.h:290

CPN::QueueBase::lock

PthreadMutex lock

Definition: QueueBase.h:289

Here is the caller graph for this function:

void CPN::RemoteQueue::WaitForData ( )

privatevirtual

Reimplemented from CPN::QueueBase.

Definition at line 161 of file RemoteQueue.cc.

References ASSERT, clock, FUNC_TRACE, CPN::QueueBase::logger, mode, pendingBlock, READ, CPN::QueueBase::ReadBlocked(), readclock, Signal(), tagUpdated, CPN::QueueBase::Wait(), and CPN::QueueBase::WaitForData().

                                   {
         FUNC_TRACE(logger);
         ASSERT(mode == READ);
         pendingBlock = true;
         tagUpdated = false;
         uint64_t saveclock = clock + 1;
         Signal();
         while (ReadBlocked() && (!tagUpdated || saveclock > readclock)) {
             Wait();
         }
         if (ReadBlocked() && tagUpdated) {
             ThresholdQueue::WaitForData();
         }
     }

Here is the call graph for this function:

void CPN::RemoteQueue::WaitForFreespace ( )

privatevirtual

Reimplemented from CPN::QueueBase.

Definition at line 176 of file RemoteQueue.cc.

References ASSERT, clock, FUNC_TRACE, CPN::QueueBase::logger, mode, pendingBlock, Signal(), tagUpdated, CPN::QueueBase::Wait(), CPN::QueueBase::WaitForFreespace(), WRITE, CPN::QueueBase::WriteBlocked(), and writeclock.

                                        {
         FUNC_TRACE(logger);
         ASSERT(mode == WRITE);
         pendingBlock = true;
         tagUpdated = false;
         uint64_t saveclock = clock + 1;
         Signal();
         while (WriteBlocked() && (!tagUpdated || saveclock > writeclock)) {
             Wait();
         }
         if (WriteBlocked() && tagUpdated) {
             ThresholdQueue::WaitForFreespace();
         }
     }

Here is the call graph for this function:

void D4R::QueueBase::WriteBlock ( unsigned qsize )

protectedinherited

writer ===> reader WriteBlock requires that you already hold the lock and if it is reentrant then a single unlock will release the lock.

Definition at line 106 of file D4RQueue.cc.

References D4R::QueueBase::Detect(), D4R::QueueBase::incomm, D4R::QueueBase::reader, D4R::QueueBase::readtagchanged, D4R::QueueBase::Signal(), D4R::QueueBase::Wait(), D4R::QueueBase::WriteBlocked(), and D4R::QueueBase::writer.

Referenced by CPN::QueueBase::GetRawEnqueuePtr(), and CPN::QueueBase::WaitForFreespace().

                                              {
         if (!reader) {
             while (WriteBlocked() && !reader) {
                 Wait();
             }
         }
         if (!WriteBlocked()) { return; }
         readtagchanged = false;
         try {
             while (incomm) { Wait(); }
             ScopeSetter<bool> ss(incomm, true);
             AutoUnlock<QueueBase> au(*this);
             writer->Block(reader->GetPublicTag(), qsize);
         } catch (...) { Signal(); throw; }
         Signal();
         while (WriteBlocked()) {
             if (readtagchanged) {
                 readtagchanged = false;
                 bool detect;
                 try {
                     while (incomm) { Wait(); }
                     ScopeSetter<bool> ss(incomm, true);
                     AutoUnlock<QueueBase> au(*this);
                     detect = writer->Transmit(reader->GetPublicTag()); 
                 } catch (...) { Signal(); throw; }
                 Signal();
                 if (detect) { Detect(); }
             } else {
                 Wait();
             }
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

bool CPN::QueueBase::WriteBlocked ( )

protectedvirtualinherited

Returns: true if we are blocked.

Implements D4R::QueueBase.

Definition at line 357 of file QueueBase.cc.

References CPN::KernelBase::CheckTerminated(), CPN::QueueBase::flushed, CPN::QueueBase::kernel, CPN::QueueBase::readshutdown, CPN::QueueBase::UnlockedFreespace(), CPN::QueueBase::writerequest, and CPN::QueueBase::writeshutdown.

Referenced by CPN::QueueBase::GetRawDequeuePtr(), WaitForFreespace(), and CPN::QueueBase::WaitForFreespace().

                                  {
         kernel->CheckTerminated();
         return (UnlockedFreespace() < writerequest || flushed) && !(readshutdown || writeshutdown);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::RemoteQueue::WriteBlockPacket ( const Packet & packet )

privatevirtual

Implements CPN::PacketHandler.

Definition at line 375 of file RemoteQueue.cc.

References ASSERT, ThresholdQueueBase::Count(), FUNC_TRACE, CPN::QueueBase::logger, mode, pendingD4RTag, CPN::ThresholdQueue::queue, READ, readerlength, CPN::Packet::Requested(), UpdateClock(), CPN::QueueBase::useD4R, CPN::QueueBase::writerequest, and CPN::QueueBase::writeshutdown.

                                                            {
         UpdateClock(packet);
         FUNC_TRACE(logger);
         ASSERT(mode == READ);
         ASSERT(!writeshutdown);
         writerequest = packet.Requested();
         if (writerequest > readerlength - queue->Count() || queue->Count() > readerlength) {
             if (useD4R) {
                 pendingD4RTag = true;
             }
         }
     }

Here is the call graph for this function:

void CPN::RemoteQueue::WriteBytes	(	const iovec *	iov,
		unsigned	iovcnt
	)

privatevirtual

Implements CPN::PacketEncoder.

Definition at line 556 of file RemoteQueue.cc.

References ASSERT, sock, FileHandle::Write(), and FileHandle::Writev().

Referenced by SendEnqueuePacket().

                                                                   {
         unsigned total = 0;
         for (unsigned i = 0; i < iovcnt; ++i) { total += iov[i].iov_len; }
         unsigned numwritten = 0;
         while (numwritten < total) {
             unsigned num = sock.Writev(iov, iovcnt);
             numwritten += num;
             if (numwritten == total) break;
             while (iov->iov_len <= num) {
                 num -= iov->iov_len;
                 ++iov;
                 --iovcnt;
             }
             if (num > 0) {
                 // Finish writing this section...
                 unsigned amount = num;
                 while (amount < iov->iov_len) {
                     amount += sock.Write(((char*)iov->iov_base) + amount, iov->iov_len - amount);
                 }
                 ++iov;
                 --iovcnt;
                 numwritten += amount - num;
             }
         }
         ASSERT(total == numwritten);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned CPN::QueueBase::WriteRequest ( )

inherited

For unit tests.

Definition at line 385 of file QueueBase.cc.

References CPN::QueueBase::writerequest.

                                      {
         AutoLock<QueueBase> al(*this);
         return writerequest;
     }

Member Data Documentation

PthreadCondition CPN::RemoteQueue::actionCond

private

Definition at line 146 of file RemoteQueue.h.

Referenced by ActionThreadEntryPoint(), FileThreadEntryPoint(), HandleError(), InternalCheckStatus(), UnlockedGrow(), UnlockedShutdown(), and ~RemoteQueue().

auto_ptr<Pthread> CPN::RemoteQueue::actionThread

private

Definition at line 143 of file RemoteQueue.h.

Referenced by FileThreadEntryPoint(), LogState(), RemoteQueue(), and ~RemoteQueue().

bool CPN::RemoteQueue::actionTick

private

Definition at line 145 of file RemoteQueue.h.

Referenced by ActionThreadEntryPoint(), and FileThreadEntryPoint().

const double CPN::RemoteQueue::alpha

private

Definition at line 149 of file RemoteQueue.h.

Referenced by GrowPacket(), and UnlockedGrow().

unsigned CPN::RemoteQueue::bytecount

private

When in write mode this is the number of bytes that we think are in the queue on the other side. When in read mode this is the number of bytes that we have read from the socket minus the number of bytes that have been dequeued.

Definition at line 168 of file RemoteQueue.h.

Referenced by DequeuePacket(), EnqueuePacket(), GetState(), InternalCheckStatus(), LogState(), ReadBlockPacket(), SendDequeuePacket(), SendEnqueuePacket(), UnlockedCount(), and UnlockedEmpty().