#include <D4RNode.h>

Collaboration diagram for D4R::Node:

Public Member Functions
	Node (uint64_t key)

	~Node ()

Tag	GetPublicTag () const

void	SetPublicTag (const Tag &t)

Tag	GetPrivateTag () const

void	SetPrivateTag (const Tag &t)

void	AddReader (weak_ptr< QueueBase > q)

void	AddWriter (weak_ptr< QueueBase > q)

void	Block (const Tag &t, unsigned qsize)

bool	Transmit (const Tag &t)

Protected Member Functions
void	SignalTagChanged ()

Protected Attributes
Tag	publicTag

Tag	privateTag

PthreadMutex	taglock

std::list< weak_ptr< QueueBase > >	readerlist

std::list< weak_ptr< QueueBase > >	writerlist

Private Member Functions
	Node (const Node &)

Node &	operator= (const Node &)

Detailed Description

The node for the D4R algorithm.

Each node has a list of readers and writers. When an action that changes the Tag happens these readers and writers are notified. Note that SetPrivateTag and SetPublicTag do not notify the readers and writers.

Definition at line 84 of file D4RNode.h.

Constructor & Destructor Documentation

D4R::Node::Node ( uint64_t key )

Definition at line 38 of file D4RNode.cc.

         : publicTag(key),
         privateTag(key)
     {
     }

D4R::Node::~Node ( )

Definition at line 44 of file D4RNode.cc.

44 {}

D4R::Node::Node ( const Node & )

private

Member Function Documentation

void D4R::Node::AddReader ( weak_ptr< QueueBase > q )

Parameters

q	add the q to the readers.

Definition at line 107 of file D4RNode.cc.

References readerlist, and taglock.

                                               {
         AutoLock<PthreadMutex> al(taglock);
         readerlist.push_back(q);
     }

void D4R::Node::AddWriter ( weak_ptr< QueueBase > q )

Parameters

q	Add the q to the writers.

Definition at line 111 of file D4RNode.cc.

References taglock, and writerlist.

                                               {
         AutoLock<PthreadMutex> al(taglock);
         writerlist.push_back(q);
     }

void D4R::Node::Block	(	const Tag &	t,
		unsigned	qsize
	)

Perform the block operation. Note the caller cannot be holding any queue locks.

Parameters

t	The tag of the node we are blocking on
qsize	The size of the queue if we are blocking on write or -1 if we are blocking on read.

Definition at line 66 of file D4RNode.cc.

References D4R::Tag::Count(), DEBUG, D4R::Tag::Key(), privateTag, publicTag, D4R::Tag::QueueSize(), SignalTagChanged(), taglock, and AutoLock< Lockable >::Unlock().

                                                  {
         AutoLock<PthreadMutex> al(taglock);
         privateTag.QueueSize(qsize);
         privateTag.Count(std::max(publicTag.Count(), t.Count()) + 1);
         DEBUG("Node %llu:%llu block %d\n", privateTag.Count(), privateTag.Key(), (int)privateTag.QueueSize());
         publicTag = privateTag;
         al.Unlock();
         SignalTagChanged();
     }

Here is the call graph for this function:

Tag D4R::Node::GetPrivateTag ( ) const

Definition at line 56 of file D4RNode.cc.

References privateTag, and taglock.

                                   {
         AutoLock<PthreadMutex> al(taglock);
         return privateTag;
     }

Tag D4R::Node::GetPublicTag ( ) const

Definition at line 46 of file D4RNode.cc.

References publicTag, and taglock.

                                  {
         AutoLock<PthreadMutex> al(taglock);
         return publicTag;
     }

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

private

void D4R::Node::SetPrivateTag ( const Tag & t )

Definition at line 61 of file D4RNode.cc.

References privateTag, and taglock.

                                          {
         AutoLock<PthreadMutex> al(taglock);
         privateTag = t;
     }

void D4R::Node::SetPublicTag ( const Tag & t )

Definition at line 51 of file D4RNode.cc.

References publicTag, and taglock.

                                         {
         AutoLock<PthreadMutex> al(taglock);
         publicTag = t;
     }

void D4R::Node::SignalTagChanged ( )

protected

Definition at line 140 of file D4RNode.cc.

References D4R::GetQueues(), readerlist, D4R::SignalReader(), D4R::SignalWriter(), taglock, and writerlist.

Referenced by Block(), and Transmit().

                                 {
         std::list<shared_ptr<QueueBase> > readers;
         std::list<shared_ptr<QueueBase> > writers;
         {
             AutoLock<PthreadMutex> al(taglock);
             GetQueues(readerlist, readers);
             GetQueues(writerlist, writers);
         }
         std::for_each(readers.begin(), readers.end(), &SignalReader);
         std::for_each(writers.begin(), writers.end(), &SignalWriter);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

bool D4R::Node::Transmit ( const Tag & t )

Called by the queue when the Tag on the node we are blocked on changes. Note the caller cannot be holding any queue locks.

Parameters

t	The new tag.

Returns: true if we have detected deadlock false otherwise.

Definition at line 76 of file D4RNode.cc.

References D4R::Tag::Count(), DEBUG, D4R::Tag::Key(), D4R::Tag::Priority(), privateTag, publicTag, D4R::Tag::QueueKey(), D4R::Tag::QueueSize(), SignalTagChanged(), taglock, and AutoLock< Lockable >::Unlock().

                                     {
         AutoLock<PthreadMutex> al(taglock);
         if (publicTag < t) {
 
             DEBUG("Transfer: publicTag < t\n\tPrivate: (%llu, %llu, %d, %llu)\n\tPublic: (%llu, %llu, %d, %llu)\n\t     t: (%llu, %llu, %d, %llu)\n",
                     privateTag.Count(), privateTag.Key(), (int)privateTag.QueueSize(), privateTag.QueueKey(),
                     publicTag.Count(), publicTag.Key(), (int)publicTag.QueueSize(), publicTag.QueueKey(),
                     t.Count(), t.Key(), (int)t.QueueSize(), t.QueueKey());
 
             uint128_t priority = std::min(privateTag.Priority(), t.Priority());
             publicTag = t;
             publicTag.Priority(priority);
             al.Unlock();
             SignalTagChanged();
         } else if (publicTag == t) {
 
             DEBUG("Transfer: publicTag == t\n\tPrivate: (%llu, %llu, %d, %llu)\n\tPublic: (%llu, %llu, %d, %llu)\n\t     t: (%llu, %llu, %d, %llu)\n",
                     privateTag.Count(), privateTag.Key(), (int)privateTag.QueueSize(), privateTag.QueueKey(),
                     publicTag.Count(), publicTag.Key(), (int)publicTag.QueueSize(), publicTag.QueueKey(),
                     t.Count(), t.Key(), (int)t.QueueSize(), t.QueueKey());
 
             return publicTag.Priority() == privateTag.Priority();
         } else {
             DEBUG("Transfer: publicTag > t NOP\n\tPrivate: (%llu, %llu, %d, %llu)\n\tPublic: (%llu, %llu, %d, %llu)\n\t     t: (%llu, %llu, %d, %llu)\n",
                     privateTag.Count(), privateTag.Key(), (int)privateTag.QueueSize(), privateTag.QueueKey(),
                     publicTag.Count(), publicTag.Key(), (int)publicTag.QueueSize(), publicTag.QueueKey(),
                     t.Count(), t.Key(), (int)t.QueueSize(), t.QueueKey());
         }
         return false;
     }