ManagedBuffer.cpp

Go to the documentation of this file.

/*
 * ManagedBuffer.cpp
 *
 *  This file is part of the HausmiSEP project
 *
 *  Copyright (C) 2012, 2013 Marco Alvarado (malvcr@gmail.com)
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <HSEP/ManagedBuffer.h>
#include <cstring>

using namespace std;

namespace HSEP {

    char* ManagedBuffer::calcAddressPtr(char* pBufferPtr, int pSlotId) const {

        char* vSlotPtr =
                pBufferPtr +           // data buffer start point
                sizeof(int)*aSlotQty + // free index queue
                (aSlotSize *           // a memory slot size
                pSlotId);              // zero based slot position

        return vSlotPtr;

    } // ManagedBuffer::calcAddress

    void ManagedBuffer::cleanSlot(char* pBufferPtr, int pSlotId) {
        char* vSlotPtr = calcAddressPtr(pBufferPtr,pSlotId);
        memset(vSlotPtr,0,aSlotSize);
    } // ManagedBuffer::cleanSlot


    void ManagedBuffer::pushFree(char* pSharedBufferPtr, int pSlotId) {

        // aMutex is a SharedMutex ... with GCC there is an issue with the
        // polymorphism, because it is not recognizing the inheritance and
        // uses the aMutex as a local variable instead of a class attribute.
        //
        ExclusiveScope((Mutex*)&aMutex);

        if (aLastFreeSlot != (aSlotQty-1)) {
            aLastFreeSlot++;
            int* vQueueHeadPtr = (int*)pSharedBufferPtr;
            vQueueHeadPtr[aLastFreeSlot] = pSlotId;
        }

    } // ManagedBuffer::pushFree

    int  ManagedBuffer::popFree(char* pSharedBufferPtr) {

        ExclusiveScope((Mutex*)&aMutex);

        int vResult = -1;

        if (aLastFreeSlot >= 0) {
            int* vQueueHeadPtr = (int*)pSharedBufferPtr;
            vResult = vQueueHeadPtr[aLastFreeSlot];
            aLastFreeSlot--;
        }

        return vResult;

    } // ManagedBuffer::popFree

    const char* ManagedBuffer::dataPtr(char* pSharedBufferPtr) const {

        return pSharedBufferPtr+(aSlotQty*sizeof(int));

    } // ManagedBuffer::data

    size_t ManagedBuffer::dataSize() const {

        return (aSlotQty*sizeof(int) + (aSlotQty*aSlotSize));

    } // ManagedBuffer::dataSize


    int ManagedBuffer::wait() {

        int vResult;

        aGate.wait();
        vResult = aSignaledSlot;

        return vResult;

    } // ManagedBuffer::wait


    void ManagedBuffer::signal(int pSlotId) {

        aSignaledSlot = pSlotId;
        aGate.signal();

    } // ManagedBuffer::signal

} // HSEP namespace