#include <D4RQueue.h>

Inheritance diagram for D4R::QueueBase:

Collaboration diagram for D4R::QueueBase:

Public Member Functions
	QueueBase ()

virtual	~QueueBase ()

void	SetReaderNode (shared_ptr< Node > n)

void	SetWriterNode (shared_ptr< Node > n)


virtual void	Lock () const =0

virtual void	Unlock () const =0


void	SignalReaderTagChanged ()

void	SignalWriterTagChanged ()

Protected Member Functions
void	ReadBlock ()

void	WriteBlock (unsigned qsize)

virtual bool	ReadBlocked ()=0

virtual bool	WriteBlocked ()=0

virtual void	Detect ()=0

virtual void	UnlockedSignalReaderTagChanged ()

virtual void	UnlockedSignalWriterTagChanged ()

virtual void	Wait ()=0

virtual void	Signal ()=0

Protected Attributes
shared_ptr< Node >	reader

shared_ptr< Node >	writer

bool	readtagchanged

bool	writetagchanged

bool	incomm

Private Member Functions
	QueueBase (const QueueBase &)

QueueBase &	operator= (const QueueBase &)

Detailed Description

The base class for the D4R queue. This class provides methods for the queue to block and override.

Definition at line 39 of file D4RQueue.h.

Constructor & Destructor Documentation

D4R::QueueBase::QueueBase ( )

Definition at line 51 of file D4RQueue.cc.

         : readtagchanged(false),
         writetagchanged(false),
         incomm(false)
     {}

D4R::QueueBase::~QueueBase ( )

virtual

Reimplemented in CPN::QueueBase.

Definition at line 57 of file D4RQueue.cc.

57 {}

D4R::QueueBase::QueueBase ( const QueueBase & )

private

Member Function Documentation

virtual void D4R::QueueBase::Detect ( )

protectedpure virtual

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

Implemented in CPN::QueueBase.

Referenced by WriteBlock().

Here is the caller graph for this function:

virtual void D4R::QueueBase::Lock ( ) const

pure virtual

These functions are to access the lock for the queue.

Implemented in CPN::QueueBase.

QueueBase& D4R::QueueBase::operator= ( const QueueBase & )

private

void D4R::QueueBase::ReadBlock ( )

protected

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 incomm, ReadBlocked(), reader, Signal(), Wait(), writer, and 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:

virtual bool D4R::QueueBase::ReadBlocked ( )

protectedpure virtual

Returns: true if we are blocked

Implemented in CPN::QueueBase.

Referenced by ReadBlock().

Here is the caller graph for this function:

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

Set the node which is reading from this queue

Parameters

n the node

Definition at line 59 of file D4RQueue.cc.

References reader, and Signal().

Referenced by CPN::RemoteQueue::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 D4R::QueueBase::SetWriterNode ( shared_ptr< Node > n )

Set the node which is writing to this queue.

Parameters

n the node

Definition at line 65 of file D4RQueue.cc.

References Signal(), and writer.

Referenced by CPN::RemoteQueue::RemoteQueue().

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

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void D4R::QueueBase::Signal ( )

protectedpure virtual

Signal that Wait should return

Implemented in CPN::QueueBase, and CPN::RemoteQueue.

Referenced by ReadBlock(), SetReaderNode(), SetWriterNode(), UnlockedSignalReaderTagChanged(), UnlockedSignalWriterTagChanged(), and WriteBlock().

Here is the caller graph for this function:

void D4R::QueueBase::SignalReaderTagChanged ( )

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

Definition at line 139 of file D4RQueue.cc.

References UnlockedSignalReaderTagChanged().

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

Here is the call graph for this function:

void D4R::QueueBase::SignalWriterTagChanged ( )

Definition at line 150 of file D4RQueue.cc.

References UnlockedSignalWriterTagChanged().

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

Here is the call graph for this function:

virtual void D4R::QueueBase::Unlock ( ) const

pure virtual

Implemented in CPN::QueueBase.

void D4R::QueueBase::UnlockedSignalReaderTagChanged ( )

protectedvirtual

Reimplemented in CPN::RemoteQueue.

Definition at line 144 of file D4RQueue.cc.

References DEBUG, reader, readtagchanged, Signal(), and writer.

Referenced by CPN::RemoteQueue::D4RTagPacket(), SignalReaderTagChanged(), and CPN::RemoteQueue::UnlockedSignalReaderTagChanged().

                                                    {
         DEBUG("%s: (%llu -> %llu)\n", __PRETTY_FUNCTION__, (writer ? writer->GetPrivateTag().Key() : 0), (reader ? reader->GetPrivateTag().Key() : 0));
         readtagchanged = true;
         Signal();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void D4R::QueueBase::UnlockedSignalWriterTagChanged ( )

protectedvirtual

Reimplemented in CPN::RemoteQueue.

Definition at line 155 of file D4RQueue.cc.

References DEBUG, reader, Signal(), writer, and writetagchanged.

Referenced by CPN::RemoteQueue::D4RTagPacket(), SignalWriterTagChanged(), and CPN::RemoteQueue::UnlockedSignalWriterTagChanged().

                                                    {
         DEBUG("%s: (%llu -> %llu)\n", __PRETTY_FUNCTION__, (writer ? writer->GetPrivateTag().Key() : 0), (reader ? reader->GetPrivateTag().Key() : 0));
         writetagchanged = true;
         Signal();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void D4R::QueueBase::Wait ( )

protectedpure virtual

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

Implemented in CPN::QueueBase.

Referenced by ReadBlock(), and WriteBlock().

Here is the caller graph for this function:

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

protected

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 Detect(), incomm, reader, readtagchanged, Signal(), Wait(), WriteBlocked(), and 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();
             }
         }
     }