osrwlock.h

/******************************************************************************
 
    @file    IntrOS: osrwlock.h
    @author  Rajmund Szymanski
    @date    17.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_RWL_H
#define __INTROS_RWL_H
 
#include "oskernel.h"
#include "osclock.h"

 
/* -------------------------------------------------------------------------- */
 
#define RDR_LIMIT    ( 0U-1 )

 
typedef struct __rwl rwl_t;
 
struct __rwl
{
    obj_t    obj;   
 
    tsk_t  * queue; 
    bool     write; 
    unsigned count; 
};
 
typedef struct __rwl rwl_id [];
 
/******************************************************************************
 *
 * Name              : _RWL_INIT
 *
 * Description       : create and initialize a read/write lock object
 *
 * Parameters        : none
 *
 * Return            : read/write lock object
 *
 * Note              : for internal use
 *
 ******************************************************************************/
 
#define               _RWL_INIT() { _OBJ_INIT(), NULL, false, 0 }

 
#define             OS_RWL( rwl ) \
                       rwl_t rwl[] = { _RWL_INIT() }

/** static alias of OS_RWL() */
#define         static_RWL( rwl ) \
                static rwl_t rwl[] = { _RWL_INIT() }

 
#ifndef __cplusplus
#define                RWL_INIT() \
                      _RWL_INIT()
#endif

 
#ifndef __cplusplus
#define                RWL_CREATE() \
                     { RWL_INIT  () }
/** alias of RWL_CREATE() */
#define                RWL_NEW \
                       RWL_CREATE
#endif
 
#ifdef __cplusplus
extern "C" {
#endif

 
void rwl_init( rwl_t *rwl );

 
void rwl_reset( rwl_t *rwl );

__STATIC_INLINE
void rwl_kill( rwl_t *rwl ) { rwl_reset(rwl); }

 
int rwl_takeRead( rwl_t *rwl );

__STATIC_INLINE
int rwl_tryLockRead( rwl_t *rwl ) { return rwl_takeRead(rwl); }

 
int rwl_waitReadFor( rwl_t *rwl, cnt_t delay );

 
int rwl_waitReadUntil( rwl_t *rwl, cnt_t time );

 
__STATIC_INLINE
int rwl_waitRead( rwl_t *rwl ) { return rwl_waitReadFor(rwl, INFINITE); }

__STATIC_INLINE
int rwl_lockRead( rwl_t *rwl ) { return rwl_waitRead(rwl); }

 
void rwl_giveRead( rwl_t *rwl );

__STATIC_INLINE
void rwl_unlockRead( rwl_t *rwl ) { rwl_giveRead(rwl); }

 
int rwl_takeWrite( rwl_t *rwl );

__STATIC_INLINE
int rwl_tryLockWrite( rwl_t *rwl ) { return rwl_takeWrite(rwl); }

 
int rwl_waitWriteFor( rwl_t *rwl, cnt_t delay );

 
int rwl_waitWriteUntil( rwl_t *rwl, cnt_t time );

 
__STATIC_INLINE
int rwl_waitWrite( rwl_t *rwl ) { return rwl_waitWriteFor(rwl, INFINITE); }

__STATIC_INLINE
int rwl_lockWrite( rwl_t *rwl ) { return rwl_waitWrite(rwl); }

 
void rwl_giveWrite( rwl_t *rwl );

__STATIC_INLINE
void rwl_unlockWrite( rwl_t *rwl ) { rwl_giveWrite(rwl); }
 
#ifdef __cplusplus
}
#endif
 
/* -------------------------------------------------------------------------- */
 
#if defined(__cplusplus)
namespace intros {

 
struct RWLock : public __rwl
{
    constexpr
    RWLock(): __rwl _RWL_INIT() {}
 
    ~RWLock() { assert(__rwl::write == false && __rwl::count == 0); }

    /// move constructor
    RWLock( RWLock&& _src ): __rwl(_src)
    {
        assert(_src.write == false && _src.count == 0 && _src.obj.queue == nullptr && _src.queue == nullptr);
    }
 
    RWLock( const RWLock& ) = delete;
    RWLock& operator=( RWLock&& ) = delete;
    RWLock& operator=( const RWLock& ) = delete;
 
    void reset         ()                  {        rwl_reset         (this); }                       
    void kill          ()                  {        rwl_kill          (this); }                       
    int  takeRead      ()                  { return rwl_takeRead      (this); }                       
    int  tryLockRead   ()                  { return rwl_tryLockRead   (this); }                       
    template<typename T>
    int  waitReadFor   ( const T& _delay ) { return rwl_waitReadFor   (this, Clock::count(_delay)); } 
    template<typename T>
    int  waitReadUntil ( const T& _time )  { return rwl_waitReadUntil (this, Clock::until(_time)); }  
    int  waitRead      ()                  { return rwl_waitRead      (this); }                       
    int  lockRead      ()                  { return rwl_lockRead      (this); }                       
    void giveRead      ()                  {        rwl_giveRead      (this); }                       
    void unlockRead    ()                  {        rwl_unlockRead    (this); }                       
    int  takeWrite     ()                  { return rwl_takeWrite     (this); }                       
    int  tryLockWrite  ()                  { return rwl_tryLockWrite  (this); }                       
    template<typename T>
    int  waitWriteFor  ( const T& _delay ) { return rwl_waitWriteFor  (this, Clock::count(_delay)); } 
    template<typename T>
    int  waitWriteUntil( const T& _time )  { return rwl_waitWriteUntil(this, Clock::until(_time)); }  
    int  waitWrite     ()                  { return rwl_waitWrite     (this); }                       
    int  lockWrite     ()                  { return rwl_lockWrite     (this); }                       
    void giveWrite     ()                  {        rwl_giveWrite     (this); }                       
    void unlockWrite   ()                  {        rwl_unlockWrite   (this); }                       
};

 
struct ReadLock
{
    explicit
    ReadLock( RWLock& _rwl ): lck_(&_rwl)
    {
        int result = lck_->lockRead();
        assert(result == E_SUCCESS || result == E_STOPPED);
        if (result != E_SUCCESS)
            lck_ = nullptr; // nothing to release
    }
 
    ~ReadLock()
    {
        if (lck_ != nullptr)
            lck_->unlockRead();
    }

    /// move constructor
    ReadLock( ReadLock&& _src ): lck_(_src.lck_)
    {
        _src.lck_ = nullptr;
    }

    bool ownsLock() const { return lck_ != nullptr; }
 
    explicit
    operator bool() const { return ownsLock(); } 
 
    ReadLock( const ReadLock& ) = delete;
    ReadLock& operator=( ReadLock&& ) = delete;
    ReadLock& operator=( const ReadLock& ) = delete;
 
    private:
    RWLock *lck_;
};

 
struct WriteLock
{
    explicit
    WriteLock( RWLock& _rwl ): lck_(&_rwl)
    {
        int result = lck_->lockWrite();
        assert(result == E_SUCCESS || result == E_STOPPED);
        if (result != E_SUCCESS)
            lck_ = nullptr; // nothing to release
    }
 
    ~WriteLock()
    {
        if (lck_ != nullptr)
            lck_->unlockWrite();
    }

    /// move constructor
    WriteLock( WriteLock&& _src ): lck_(_src.lck_)
    {
        _src.lck_ = nullptr;
    }

    bool ownsLock() const { return lck_ != nullptr; }
 
    explicit
    operator bool() const { return ownsLock(); } 
 
    WriteLock( const WriteLock& ) = delete;
    WriteLock& operator=( WriteLock&& ) = delete;
    WriteLock& operator=( const WriteLock& ) = delete;
 
    private:
    RWLock *lck_;
};
 
}     //  namespace
#endif//__cplusplus
 
/* -------------------------------------------------------------------------- */

 
#endif//__INTROS_RWL_H