osjobqueue.h

/******************************************************************************
 
    @file    IntrOS: osjobqueue.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_JOB_H
#define __INTROS_JOB_H
 
#include "oskernel.h"
#include "osclock.h"


 
typedef struct __job job_t;
 
struct __job
{
    obj_t    obj;   
 
    unsigned count; 
    unsigned limit; 
 
    unsigned head;  
    unsigned tail;  
    fun_t ** data;  
};
 
typedef struct __job job_id [];
 
/******************************************************************************
 *
 * Name              : _JOB_INIT
 *
 * Description       : create and initialize a job queue object
 *
 * Parameters
 *   limit           : size of a queue (max number of stored job procedures)
 *   data            : job queue data buffer
 *
 * Return            : job queue object
 *
 * Note              : for internal use
 *
 ******************************************************************************/
 
#define               _JOB_INIT( _limit, _data ) { _OBJ_INIT(), 0, _limit, 0, 0, _data }
 
/******************************************************************************
 *
 * Name              : _JOB_DATA
 *
 * Description       : create a job queue data buffer
 *
 * Parameters
 *   limit           : size of a queue (max number of stored job procedures)
 *
 * Return            : job queue data buffer
 *
 * Note              : for internal use
 *
 ******************************************************************************/
 
#ifndef __cplusplus
#define               _JOB_DATA( _limit ) (fun_t *[_limit]){ NULL }
#endif

 
#define             OS_JOB_BUFFER( buf, size ) \
                       fun_t *buf[size]

 
#define             OS_JOB( job, limit )        \
                static fun_t *job##__buf[limit]; \
                       job_t job[] = { _JOB_INIT( limit, job##__buf ) }

/** static alias of OS_JOB() */
#define         static_JOB( job, limit )        \
                static fun_t *job##__buf[limit]; \
                static job_t job[] = { _JOB_INIT( limit, job##__buf ) }

 
#ifndef __cplusplus
#define                JOB_INIT( limit ) \
                      _JOB_INIT( limit, _JOB_DATA( limit ) )
#endif

 
#ifndef __cplusplus
#define                JOB_CREATE( limit ) \
                     { JOB_INIT  ( limit ) }
/** alias of JOB_CREATE() */
#define                JOB_NEW \
                       JOB_CREATE
#endif
 
#ifdef __cplusplus
extern "C" {
#endif

 
void job_init( job_t *job, fun_t **data, size_t bufsize );

 
void job_reset( job_t *job );

__STATIC_INLINE
void job_kill( job_t *job ) { job_reset(job); }

 
int job_take( job_t *job );

__STATIC_INLINE
int job_tryWait( job_t *job ) { return job_take(job); }
 
#if OS_ATOMICS
int job_takeAsync( job_t *job );
#endif

 
int job_waitFor( job_t *job, cnt_t delay );

 
int job_waitUntil( job_t *job, cnt_t time );

 
__STATIC_INLINE
int job_wait( job_t *job ) { return job_waitFor(job, INFINITE); }
 
#if OS_ATOMICS
int job_waitAsync( job_t *job );
#endif

 
int job_give( job_t *job, fun_t *fun );
 
#if OS_ATOMICS
int job_giveAsync( job_t *job, fun_t *fun );
#endif

 
int job_sendFor( job_t *job, fun_t *fun, cnt_t delay );

 
int job_sendUntil( job_t *job, fun_t *fun, cnt_t time );

 
__STATIC_INLINE
int job_send( job_t *job, fun_t *fun ) { return job_sendFor(job, fun, INFINITE); }
 
#if OS_ATOMICS
int job_sendAsync( job_t *job, fun_t *fun );
#endif

 
void job_push( job_t *job, fun_t *fun );

 
unsigned job_count( job_t *job );

 
unsigned job_space( job_t *job );

 
unsigned job_limit( job_t *job );
 
#ifdef __cplusplus
}
#endif
 
/* -------------------------------------------------------------------------- */
 
#if defined(__cplusplus)
namespace intros {

 
template<unsigned limit_>
struct JobQueueT : public __job
{
    constexpr
    JobQueueT(): __job _JOB_INIT(limit_, data_) {}
 
    ~JobQueueT() { assert(__job::obj.queue == nullptr); }

    /// move constructor
    JobQueueT( JobQueueT&& _src ): __job _JOB_INIT(limit_, data_)
    {
        assert(_src.__job::count == 0 && _src.obj.queue == nullptr);
        (void) _src;
    }
 
    JobQueueT( const JobQueueT& ) = delete;
    JobQueueT& operator=( JobQueueT&& ) = delete;
    JobQueueT& operator=( const JobQueueT& ) = delete;
 
    void     reset    ()                               {        job_reset    (this); }                             
    void     kill     ()                               {        job_kill     (this); }                             
    int      take     ()                               { return job_take     (this); }                             
    int      tryWait  ()                               { return job_tryWait  (this); }                             
    template<typename T>
    int      waitFor  ( const T& _delay )              { return job_waitFor  (this, Clock::count(_delay)); }       
    template<typename T>
    int      waitUntil( const T& _time )               { return job_waitUntil(this, Clock::until(_time)); }        
    int      wait     ()                               { return job_wait     (this); }                             
    int      give     ( fun_t *_fun )                  { return job_give     (this, _fun); }                       
    template<typename T>
    int      sendFor  ( fun_t *_fun, const T& _delay ) { return job_sendFor  (this, _fun, Clock::count(_delay)); } 
    template<typename T>
    int      sendUntil( fun_t *_fun, const T& _time )  { return job_sendUntil(this, _fun, Clock::until(_time)); }  
    int      send     ( fun_t *_fun )                  { return job_send     (this, _fun); }                       
    void     push     ( fun_t *_fun )                  {        job_push     (this, _fun); }                       
    unsigned count    ()                               { return job_count    (this); }                             
    unsigned space    ()                               { return job_space    (this); }                             
    unsigned limit    ()                               { return job_limit    (this); }                             
#if OS_ATOMICS
    int      takeAsync()                               { return job_takeAsync(this); }                             
    int      waitAsync()                               { return job_waitAsync(this); }                             
    int      giveAsync( fun_t *_fun )                  { return job_giveAsync(this, _fun); }                       
    int      sendAsync( fun_t *_fun )                  { return job_sendAsync(this, _fun); }                       
#endif
 
    private:
    fun_t *data_[limit_];
};
 
}     //  namespace
#endif//__cplusplus
 
/* -------------------------------------------------------------------------- */

 
#endif//__INTROS_JOB_H