SingleProducerConsumer.h

Go to the documentation of this file.

#ifndef __SINGLE_PRODUCER_CONSUMER_H
#define __SINGLE_PRODUCER_CONSUMER_H

#include "RakAssert.h"

static const int MINIMUM_LIST_SIZE=8;

#include "RakMemoryOverride.h"
#include "Export.h"

namespace DataStructures
{
        template <class SingleProducerConsumerType>
        class RAK_DLL_EXPORT SingleProducerConsumer
        {
        public:
                // Constructor
                SingleProducerConsumer();

                // Destructor
                ~SingleProducerConsumer();

                SingleProducerConsumerType* WriteLock(void);

                void CancelWriteLock(SingleProducerConsumerType* cancelToLocation);

                void WriteUnlock(void);

                SingleProducerConsumerType* ReadLock(void);

                // Cancelling locks cancels all locks back up to the data passed.  So if you lock twice and cancel using the first lock, the second lock is ignored
                void CancelReadLock(SingleProducerConsumerType* cancelToLocation);

                void ReadUnlock(void);

                void Clear(void);

                int Size(void) const;

                bool CheckReadUnlockOrder(const SingleProducerConsumerType* data) const;

                bool ReadIsLocked(void) const;

        private:
                struct DataPlusPtr
                {
                        DataPlusPtr () {readyToRead=false;}
                        SingleProducerConsumerType object;

                        // Ready to read is so we can use an equality boolean comparison, in case the writePointer var is trashed while context switching.
                        volatile bool readyToRead;
                        volatile DataPlusPtr *next;
                };
                volatile DataPlusPtr *readAheadPointer;
                volatile DataPlusPtr *writeAheadPointer;
                volatile DataPlusPtr *readPointer;
                volatile DataPlusPtr *writePointer;
                unsigned readCount, writeCount;
        };

        template <class SingleProducerConsumerType>
                SingleProducerConsumer<SingleProducerConsumerType>::SingleProducerConsumer()
        {
                // Preallocate
                readPointer = RakNet::OP_NEW<DataPlusPtr>( __FILE__, __LINE__ );
                writePointer=readPointer;
                readPointer->next = RakNet::OP_NEW<DataPlusPtr>( __FILE__, __LINE__ );
                int listSize;
#ifdef _DEBUG
                RakAssert(MINIMUM_LIST_SIZE>=3);
#endif
                for (listSize=2; listSize < MINIMUM_LIST_SIZE; listSize++)
                {
                        readPointer=readPointer->next;
                        readPointer->next = RakNet::OP_NEW<DataPlusPtr>( __FILE__, __LINE__ );
                }
                readPointer->next->next=writePointer; // last to next = start
                readPointer=writePointer;
                readAheadPointer=readPointer;
                writeAheadPointer=writePointer;
                readCount=writeCount=0;
        }

        template <class SingleProducerConsumerType>
                SingleProducerConsumer<SingleProducerConsumerType>::~SingleProducerConsumer()
        {
                volatile DataPlusPtr *next;
                readPointer=writeAheadPointer->next;
                while (readPointer!=writeAheadPointer)
                {
                        next=readPointer->next;
                        RakNet::OP_DELETE((char*) readPointer, __FILE__, __LINE__);
                        readPointer=next;
                }
                RakNet::OP_DELETE((char*) readPointer, __FILE__, __LINE__);
        }

        template <class SingleProducerConsumerType>
                SingleProducerConsumerType* SingleProducerConsumer<SingleProducerConsumerType>::WriteLock( void )
        {
                if (writeAheadPointer->next==readPointer ||
                        writeAheadPointer->next->readyToRead==true)
                {
                        volatile DataPlusPtr *originalNext=writeAheadPointer->next;
                        writeAheadPointer->next=RakNet::OP_NEW<DataPlusPtr>(__FILE__, __LINE__);
                        RakAssert(writeAheadPointer->next);
                        writeAheadPointer->next->next=originalNext;
                }

                volatile DataPlusPtr *last;
                last=writeAheadPointer;
                writeAheadPointer=writeAheadPointer->next;

                return (SingleProducerConsumerType*) last;
        }

        template <class SingleProducerConsumerType>
                void SingleProducerConsumer<SingleProducerConsumerType>::CancelWriteLock( SingleProducerConsumerType* cancelToLocation )
        {
                writeAheadPointer=(DataPlusPtr *)cancelToLocation;
        }

        template <class SingleProducerConsumerType>
                void SingleProducerConsumer<SingleProducerConsumerType>::WriteUnlock( void )
        {
                //      DataPlusPtr *dataContainer = (DataPlusPtr *)structure;

#ifdef _DEBUG
                RakAssert(writePointer->next!=readPointer);
                RakAssert(writePointer!=writeAheadPointer);
#endif

                writeCount++;
                // User is done with the data, allow send by updating the write pointer
                writePointer->readyToRead=true;
                writePointer=writePointer->next;
        }

        template <class SingleProducerConsumerType>
                SingleProducerConsumerType* SingleProducerConsumer<SingleProducerConsumerType>::ReadLock( void )
        {
                        if (readAheadPointer==writePointer ||
                                readAheadPointer->readyToRead==false)
                        {
                                return 0;
                        }

                        volatile DataPlusPtr *last;
                        last=readAheadPointer;
                        readAheadPointer=readAheadPointer->next;
                        return (SingleProducerConsumerType*)last;
        }

        template <class SingleProducerConsumerType>
                void SingleProducerConsumer<SingleProducerConsumerType>::CancelReadLock( SingleProducerConsumerType* cancelToLocation )
        {
#ifdef _DEBUG
                RakAssert(readPointer!=writePointer);
#endif
                readAheadPointer=(DataPlusPtr *)cancelToLocation;
        }

        template <class SingleProducerConsumerType>
                void SingleProducerConsumer<SingleProducerConsumerType>::ReadUnlock( void )
        {
#ifdef _DEBUG
                RakAssert(readAheadPointer!=readPointer); // If hits, then called ReadUnlock before ReadLock
                RakAssert(readPointer!=writePointer); // If hits, then called ReadUnlock when Read returns 0
#endif
                readCount++;

                // Allow writes to this memory block
                readPointer->readyToRead=false;
                readPointer=readPointer->next;
        }

        template <class SingleProducerConsumerType>
                void SingleProducerConsumer<SingleProducerConsumerType>::Clear( void )
        {
                // Shrink the list down to MINIMUM_LIST_SIZE elements
                volatile DataPlusPtr *next;
                writePointer=readPointer->next;

                int listSize=1;
                next=readPointer->next;
                while (next!=readPointer)
                {
                        listSize++;
                        next=next->next;
                }

                while (listSize-- > MINIMUM_LIST_SIZE)
                {
                        next=writePointer->next;
#ifdef _DEBUG
                        RakAssert(writePointer!=readPointer);
#endif
                        RakNet::OP_DELETE((char*) writePointer, __FILE__, __LINE__);
                        writePointer=next;
                }

                readPointer->next=writePointer;
                writePointer=readPointer;
                readAheadPointer=readPointer;
                writeAheadPointer=writePointer;
                readCount=writeCount=0;
        }

        template <class SingleProducerConsumerType>
                int SingleProducerConsumer<SingleProducerConsumerType>::Size( void ) const
        {
                return writeCount-readCount;
        }

        template <class SingleProducerConsumerType>
                bool SingleProducerConsumer<SingleProducerConsumerType>::CheckReadUnlockOrder(const SingleProducerConsumerType* data) const
        {
                return const_cast<const SingleProducerConsumerType *>(&readPointer->object) == data;
        }


        template <class SingleProducerConsumerType>
                bool SingleProducerConsumer<SingleProducerConsumerType>::ReadIsLocked(void) const
        {
                return readAheadPointer!=readPointer;
        }       
}

#endif