ossemaphore.h

/******************************************************************************
 
    @file    IntrOS: ossemaphore.h
    @author  Rajmund Szymanski
    @date    18.11.2025
    @brief   This file contains definitions for IntrOS.
 
 ******************************************************************************
 
   Copyright (c) 2018-2022 Rajmund Szymanski. All rights reserved.
 
   Permission is hereby granted, free of charge, to any person obtaining a copy
   of this software and associated documentation files (the "Software"), to
   deal in the Software without restriction, including without limitation the
   rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
   sell copies of the Software, and to permit persons to whom the Software is
   furnished to do so, subject to the following conditions:
 
   The above copyright notice and this permission notice shall be included
   in all copies or substantial portions of the Software.
 
   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
   THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
   IN THE SOFTWARE.
 
 ******************************************************************************/
 
#ifndef __INTROS_SEM_H
#define __INTROS_SEM_H
 
#include "oskernel.h"
#include "osclock.h"

 
/* -------------------------------------------------------------------------- */
 
#define semDirect    ( 0U )   
#define semBinary    ( 1U )   
#define semCounting  ( 0U-1 ) 
#define semDefault     semCounting 

 
typedef struct __sem sem_t;
 
struct __sem
{
    obj_t    obj;   
 
    unsigned count; 
    unsigned limit; 
};
 
typedef struct __sem sem_id [];
 
/******************************************************************************
 *
 * Name              : _SEM_INIT
 *
 * Description       : create and initialize a semaphore object
 *
 * Parameters
 *   init            : initial value of semaphore counter
 *   limit           : maximum value of semaphore counter
 *                     semDirect: direct semaphore
 *                     semBinary: binary semaphore
 *                     semCounting: counting semaphore
 *                     otherwise: limited semaphore
 *
 * Return            : semaphore object
 *
 * Note              : for internal use
 *
 ******************************************************************************/
 
#define               _SEM_INIT( _init, _limit ) { _OBJ_INIT(), _init < _limit ? _init : _limit, _limit }
 
/******************************************************************************
 *
 * Name              : _VA_SEM
 *
 * Description       : calculate maximum value of semaphore counter from optional parameter
 *
 * Note              : for internal use
 *
 ******************************************************************************/
 
#define               _VA_SEM( _limit ) ( (_limit + 0) ? (_limit + 0) : (semDefault) )

 
#define             OS_SEM( sem, init, ... ) \
                       sem_t sem[] = { _SEM_INIT( init, _VA_SEM(__VA_ARGS__) ) }

/** static alias of OS_SEM() */
#define         static_SEM( sem, init, ... ) \
                static sem_t sem[] = { _SEM_INIT( init, _VA_SEM(__VA_ARGS__) ) }

 
#ifndef __cplusplus
#define                SEM_INIT( init, ... ) \
                      _SEM_INIT( init, _VA_SEM(__VA_ARGS__) )
#endif

 
#ifndef __cplusplus
#define                SEM_CREATE( init, ... ) \
                     { SEM_INIT  ( init, _VA_SEM(__VA_ARGS__) ) }
/** alias of SEM_CREATE() */
#define                SEM_NEW \
                       SEM_CREATE
#endif
 
#ifdef __cplusplus
extern "C" {
#endif

 
void sem_init( sem_t *sem, unsigned init, unsigned limit );

 
void sem_reset( sem_t *sem );

__STATIC_INLINE
void sem_kill( sem_t *sem ) { sem_reset(sem); }

 
int sem_take( sem_t *sem );

__STATIC_INLINE
int sem_tryWait( sem_t *sem ) { return sem_take(sem); }
 
#if OS_ATOMICS
int sem_takeAsync( sem_t *sem );
#endif

 
int sem_waitFor( sem_t *sem, cnt_t delay );

 
int sem_waitUntil( sem_t *sem, cnt_t time );

 
__STATIC_INLINE
int sem_wait( sem_t *sem ) { return sem_waitFor(sem, INFINITE); }
 
#if OS_ATOMICS
int sem_waitAsync( sem_t *sem );
#endif

 
int sem_give( sem_t *sem );

__STATIC_INLINE
int sem_post( sem_t *sem ) { return sem_give(sem); }
 
#if OS_ATOMICS
int sem_giveAsync( sem_t *sem );
#endif

 
int sem_release( sem_t *sem, unsigned num );

 
unsigned sem_getValue( sem_t *sem );
 
#ifdef __cplusplus
}
#endif
 
/* -------------------------------------------------------------------------- */
 
#if defined(__cplusplus)
namespace intros {

 
struct Semaphore : public __sem
{
    constexpr
    Semaphore(): __sem _SEM_INIT(0, semDefault) {}
    constexpr
    Semaphore( const unsigned _init, const unsigned _limit = semDefault ): __sem _SEM_INIT(_init, _limit) {}
 
    ~Semaphore() { assert(__sem::obj.queue == nullptr); }

    /// move constructor
    Semaphore( Semaphore&& _src ): __sem(_src)
    {
        assert(_src.obj.queue == nullptr);
    }
 
    Semaphore( const Semaphore& ) = delete;
    Semaphore& operator=( Semaphore&& ) = delete;
    Semaphore& operator=( const Semaphore& ) = delete;
 
    void     reset     ()                  {        sem_reset     (this); }                       
    void     kill      ()                  {        sem_kill      (this); }                       
    int      take      ()                  { return sem_take      (this); }                       
    int      tryWait   ()                  { return sem_tryWait   (this); }                       
    template<typename T>
    int      waitFor   ( const T& _delay ) { return sem_waitFor   (this, Clock::count(_delay)); } 
    template<typename T>
    int      waitUntil ( const T& _time )  { return sem_waitUntil (this, Clock::until(_time)); }  
    int      wait      ()                  { return sem_wait      (this); }                       
    int      give      ()                  { return sem_give      (this); }                       
    int      post      ()                  { return sem_post      (this); }                       
    int      release   ( unsigned _num )   { return sem_release   (this, _num); }                 
    unsigned getValue  ()                  { return sem_getValue  (this); }                       
#if OS_ATOMICS
    int      takeAsync ()                  { return sem_takeAsync (this); }                       
    int      waitAsync ()                  { return sem_waitAsync (this); }                       
    int      giveAsync ()                  { return sem_giveAsync (this); }                       
#endif
 
#if __cplusplus >= 201402L
    using Ptr = std::unique_ptr<Semaphore>; 
#else
    using Ptr = Semaphore *; 
#endif

 
    static
    Semaphore Direct()
    {
        return { 0, semDirect };
    }

 
    static
    Semaphore Binary( const unsigned _init = 0 )
    {
        return { _init, semBinary };
    }

 
    static
    Semaphore Counting( const unsigned _init = 0 )
    {
        return { _init, semCounting };
    }
 
};
 
}     //  namespace
#endif//__cplusplus
 
/* -------------------------------------------------------------------------- */

 
#endif//__INTROS_SEM_H