nonblocking_call_queue.h

/*
  ==============================================================================

    audiothread_fifo.h
    Created: 20 Jan 2014 11:34:38am
    Author:  Jim Credland

  ==============================================================================
*/

#ifndef AUDIOTHREAD_FIFO_H_INCLUDED
#define AUDIOTHREAD_FIFO_H_INCLUDED


class LockFreeCallQueue
{
public:
    LockFreeCallQueue (int RingBufferSize)
        :
        fifo (RingBufferSize),
        acceptingJobs (true)
    {
        // TODO: data should be aligned to a cache line boundary.
        // Allocate double size buffer to easily support variable length messages,
        // by hanging them over the end of the buffer.
        fifodata = new char[ RingBufferSize * 2 ];
    }

    ~LockFreeCallQueue()
    {
        delete [] fifodata;
    }

    bool isEmpty()
    {
        return fifo.getTotalSize() == fifo.getFreeSpace();
    }

    int getFreeSpace()
    {
        return fifo.getFreeSpace();
    }

    template <class Functor>
    bool callf (Functor const& f)
    {
        if (! acceptingJobs) 
            return false;

        /* allocSize cannot be bigger than 2Gb ok!. */
        // jassert (sizeof (WorkItem<Functor>) < std::numeric_limits<int>::max());

        const int allocSize = static_cast<int>(roundUpToCacheLineBoundary (sizeof (WorkItem<Functor>)));
        int idx1, idx2, sz1, sz2;
        fifo.prepareToWrite (allocSize, idx1, sz1, idx2, sz2);

        if (sz1 + sz2 < allocSize) 
            return false;

        /* double size buffer means we can ignore idx2 and sz2.  Weird syntax for new is a 'placement
         * new'.  Familar only if you write custom allocators regularly. */
        new (fifodata + idx1) WorkItem<Functor> (f);
        fifo.finishedWrite (allocSize);

        return true;
    }

    bool synchronize()
    {
        bool didSomething = false;

        while (fifo.getNumReady() > 0)
        {
            int idx1, idx2, sz1, sz2;
            fifo.prepareToRead (1, idx1, sz1, idx2, sz2);
            didSomething = true;
            Work* w = reinterpret_cast<Work*> (fifodata + idx1);
            /* notice only one function pointer invocation here, not two virtual function calls. */
            const int sizeofWorkItem = (*w->execAndDestructFn) (w);
            const int allocSize = roundUpToCacheLineBoundary (sizeofWorkItem);
            fifo.finishedRead (allocSize);
        }

        return didSomething;
    }

    void stop()
    {
        acceptingJobs = false;
    }
private:
    /* Avoid a vtable and two separate virtual function dispatches (operator() and destructor) by putting
     everything into a single function and implementing our own virtual function call. */

    typedef int (*WorkExecAndDestructFunctionPtr) (void* workItemStorage);

    class Work
    {
        // NOTE: no vtable.
    public:
        Work (WorkExecAndDestructFunctionPtr f) :
            execAndDestructFn (f)
        { }
        WorkExecAndDestructFunctionPtr execAndDestructFn;
    };

    template <class Functor>
    struct WorkItem : public Work
    {
        explicit WorkItem (Functor const& fun) :
            Work (&WorkItem::myExecAndDestruct),
            myCall (fun)
        {}

    private:
        static int myExecAndDestruct (void* workItemStorage)
        {
            /* cast to *concrete* work item pointer of this template type */
            WorkItem* that = reinterpret_cast<WorkItem*> (workItemStorage);
            that->myCall();
            that->~WorkItem(); // invoke concrete dtor (destructs functor)
            return static_cast<int>(sizeof (WorkItem));
        }

        Functor myCall;
    };

    /* For clarity (maybe) what's happening here is:
     1  There are instances of the templated class WorkItem for each type of Functor, and hence
        multiple versions of myExecAndDestruct.
     2  When the WorkItem is created the Work::execAndDestructFn pointer is set to
        point to the appropriate instance of myExecAndDestruct - the pointer is passed
        to the Work superclass constructor by the WorkItem<Functor> class.

     To call we:
     -  Get the data from the fifo.
     -  Cast it to be a Work.
     -  Call the appropriate instance of myExecAndDestruct
        via the execAndDestructFn pointer.
    */

    AbstractFifo fifo;
    char* fifodata;

    /* Used to avoid false sharing and to give correct alignment to embedded structs. */
    int roundUpToCacheLineBoundary (int x)
    {
        return x; // TODO
    }

    bool acceptingJobs;
};





#endif  // AUDIOTHREAD_FIFO_H_INCLUDED