oc_semaphore.c

Go to the documentation of this file.

#include <oc_null.h>
#include <oc_object.h>
#include <oc_semaphore.h>
#include <oc_threadman.h>
#include <oc_stdlib.h>
#include <oc_intman.h>

#define _________________________________________TYPES_SECTION______________________________________________________________________________

struct Semaphore_t
{
    oC_ObjectControl_t      ObjectControl;
    oC_Semaphore_Type_t     Type;
    uint32_t                Value;
};

#undef  _________________________________________TYPES_SECTION______________________________________________________________________________

#define _________________________________________PROTOTYPES_SECTION_________________________________________________________________________

#undef  _________________________________________PROTOTYPES_SECTION_________________________________________________________________________

#define _________________________________________INTERFACE_FUNCTIONS_SECTION________________________________________________________________

//==========================================================================================================================================
//==========================================================================================================================================
oC_Semaphore_t oC_Semaphore_New( oC_Semaphore_Type_t Type , oC_Semaphore_InitialValue_t InitialValue , Allocator_t Allocator , AllocationFlags_t Flags )
{
    oC_Semaphore_t semaphore = ksmartalloc( sizeof(struct Semaphore_t) , Allocator , Flags );

    if(semaphore)
    {
        semaphore->Type          = Type;
        semaphore->Value         = InitialValue;
        semaphore->ObjectControl = oC_CountObjectControl(semaphore,oC_ObjectId_Semaphore);
    }

    return semaphore;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Semaphore_Delete( oC_Semaphore_t * Semaphore , AllocationFlags_t Flags  )
{
    bool deleted = false;

    if(oC_Semaphore_IsCorrect(*Semaphore))
    {
        oC_IntMan_EnterCriticalSection();
        (*Semaphore)->ObjectControl = 0;
        oC_ThreadMan_UnblockAllBlockedBy(&(*Semaphore)->Value,false);

        if(!ksmartfree(*Semaphore,sizeof(struct Semaphore_t),Flags))
        {
            oC_SaveError("Semaphore" , oC_ErrorCode_ReleaseError);
        }
        else
        {
            *Semaphore  = NULL;
            deleted     = true;
        }
        oC_IntMan_ExitCriticalSection();
    }

    return deleted;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Semaphore_IsCorrect( oC_Semaphore_t Semaphore )
{
    return oC_MemMan_IsRamAddress(Semaphore) && oC_CheckObjectControl(Semaphore,oC_ObjectId_Semaphore , Semaphore->ObjectControl);
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Semaphore_Give( oC_Semaphore_t Semaphore )
{
    bool given = false;

    if(oC_Semaphore_IsCorrect(Semaphore))
    {
        oC_IntMan_EnterCriticalSection();

        if(Semaphore->Value < Semaphore->Type)
        {
            Semaphore->Value++;
        }
        oC_IntMan_ExitCriticalSection();
        given = true;
    }

    return given;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Semaphore_GiveCounting( oC_Semaphore_t Semaphore , uint32_t Count )
{
    bool given = false;

    if(oC_Semaphore_IsCorrect(Semaphore))
    {
        oC_IntMan_EnterCriticalSection();
        Semaphore->Value += Count;

        if(Semaphore->Value > Semaphore->Type)
        {
            Semaphore->Value = Semaphore->Type;
        }

        oC_IntMan_ExitCriticalSection();
        given = true;
    }

    return given;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Semaphore_Take( oC_Semaphore_t Semaphore , oC_Time_t Timeout )
{
    bool taken = false;

    if(oC_Semaphore_IsCorrect(Semaphore))
    {
        if(Semaphore->Value == 0)
        {
            oC_Thread_t thread = oC_ThreadMan_GetCurrentThread();

            if(oC_Thread_SetBlocked(thread,&Semaphore->Value,oC_Thread_Unblock_WhenGreaterOrEqual,1,oC_Thread_UnblockMask_All,Timeout))
            {
                while(oC_Thread_IsBlocked(thread));

                oC_Thread_SetUnblocked(thread);

                oC_IntMan_EnterCriticalSection();
                if(oC_Semaphore_IsCorrect(Semaphore) && (Semaphore->Value >= 1))
                {
                    Semaphore->Value        = 0;
                    taken                   = true;
                }
                oC_IntMan_ExitCriticalSection();
            }
        }
        else
        {
            oC_IntMan_EnterCriticalSection();
            Semaphore->Value        = 0;
            taken                   = true;
            oC_IntMan_ExitCriticalSection();
        }
    }

    return taken;
}


//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Semaphore_TakeCounting( oC_Semaphore_t Semaphore , uint32_t Count , oC_Time_t Timeout )
{
    bool taken = false;

    if(oC_Semaphore_IsCorrect(Semaphore) && Count <= Semaphore->Type)
    {
        oC_IntMan_EnterCriticalSection();
        if(Semaphore->Value < Count)
        {
            oC_IntMan_ExitCriticalSection();
            oC_Thread_t thread = oC_ThreadMan_GetCurrentThread();

            if(oC_Thread_SetBlocked(thread,&Semaphore->Value, oC_Thread_Unblock_WhenGreaterOrEqual , Count , oC_Thread_UnblockMask_All , Timeout))
            {
                while(oC_Thread_IsBlocked(thread));

                oC_Thread_SetUnblocked(thread);

                oC_IntMan_EnterCriticalSection();
                if(oC_Semaphore_IsCorrect(Semaphore) && (Semaphore->Value >= Count))
                {
                    Semaphore->Value       -= Count;
                    taken                   = true;
                }
                oC_IntMan_ExitCriticalSection();
            }
        }
        else
        {
            Semaphore->Value       -= Count;
            taken                   = true;
            oC_IntMan_ExitCriticalSection();
        }
    }

    return taken;
}



#undef  _________________________________________INTERFACE_FUNCTIONS_SECTION________________________________________________________________

#define _________________________________________LOCAL_SECTION______________________________________________________________________________


#undef  _________________________________________LOCAL_SECTION______________________________________________________________________________