SyncRun impl

static inline void init_initqueueentry( initqueue_entry_t  * initentry, syncrun_f  mainfct, void  * initarg )

Initialize initentry with mainfct and initarg.  The size initargsize of the allocated init argument is set to 0.

static inline void init2_initqueueentry( initqueue_entry_t  * initentry, syncrun_f  mainfct, uint8_t  initargsize )

Initialize initentry with mainfct and initarg and initargsize.  The caller must have reserved sizeentry_initqueueentry bytes for initentry.

static inline uint16_t sizeentry_initqueueentry( uint8_t  initargsize )

The size in bytes of initqueue_entry_t depending on initargsize.  If initargsize is set to 0 the returned value equals sizeof(initqueue_entry_t).

static inline void init_runqueueentry( /*out*/runqueue_entry_t  * runentry, const  syncthread_t  * thread )

Initializes runentry with thread.  Content of thread is copied as plain bytes.

static inline void initmove_runqueueentry( /*out*/runqueue_entry_t  * dest, runqueue_entry_t  * src )

Initializes dest with src. src is not changed but considered uninitialized after the operation.

static inline void init_run2queueentry( /*out*/run2queue_entry_t  * runentry, syncthread_t  * thread, syncevent_t  * exitevent )

Initializes runentry with thread and exitevent.  After the operation exitevent has been moved into runentry and is considered uninitialized.

static inline void initmove_run2queueentry( /*out*/run2queue_entry_t  * dest, run2queue_entry_t  * src )

Initializes dest with src.  After the operation src is considered uninitialized.

static inline void init_waitqueueentry( /*out*/waitqueue_entry_t  * waitentry, syncrun_t  * srun, syncthread_t  * thread )

Initializes waitentry with thread and uses srun->waitinfo to read the event and the continuelabel.  The continuelabel stored in syncrun_t.waitinfo is the place, where execution will continue after wakeup.

static inline void initmove_waitqueueentry( /*out*/waitqueue_entry_t  * dest, waitqueue_entry_t  * src )

Moves content of initialized src to dest.  After return dest contains previous content of dest (back pointer of referenced objects are adapted).  Src is left untouched but is considered in an invalid, uninitialized state.  You have to initialize it before src can be used again.

static inline waitqueue_entry_t * cast_waitqueueentry( syncwait_t  * waitentry )

Casts pointer to syncwait_t into pointer to waitqueue_entry_t.

static inline void init_wait2queueentry( /*out*/wait2queue_entry_t  * waitentry, syncrun_t  * srun, syncthread_t  * thread, syncevent_t  * exitevent )

Initializes waitentry with thread and exitevent and uses srun->waitinfo to read the event and the continuelabel.  The continuelabel stored in syncrun_t.waitinfo is the place, where execution will continue after wakeup.

static inline void initmove_wait2queueentry( /*out*/wait2queue_entry_t  * dest, wait2queue_entry_t  * src )

Moves content of initialized src to dest.  After return dest contains previous content of dest (back pointer of referenced objects are adapted).  Src is left untouched but is considered in an invalid, uninitialized state.  You have to initialize it before src can be used again.

static inline wait2queue_entry_t * cast_wait2queueentry( syncwait_t  * waitentry )

Casts pointer to syncwait_t into pointer to wait2queue_entry_t.

static inline void preparewakeup_syncrun( syncrun_t  * srun, void  * continuelabel, int  retcode )

Sets all values in srun->wakeup (syncrun_t.wakeup).  Parameter continuelabel and retcode are copied into the corresponding data members of wakeup.  This function is called before a waiting threads is woken up.

static inline int preparerun_syncrun( syncrun_t  * srun, syncthread_t  * running_thread )

Sets all values in srun->running (syncrun_t.running).  The exitevent of the last started thread is set to 0 meaning that there is no previously started thread.  The running thread thread is set to value of parameter running_thread.  The state of the thread is initialized to syncrun_state_CONTINUE.  Therefore threads run until they exit or abort themselves.

static int execwaiting_syncrun( syncrun_t  * srun, syncwait_t  * waiting, int  retcode )

Calls callwakeup_syncthread for a waiting thread given in waiting.  The argument retcode is set into srun->wakeup and is the return code of the exited syncthread_t.  Function waitforexit_syncrun returns this retcode as its own return value.  For other types of events retcode is ignored (see waitforevent_syncrun and waitforlist_syncrun).  If the called syncthread exits or aborts and another thread waits for its exit the function calls itself.  If the waiting thread waits for another event after return it will be kept in the wait queue.  If its state is syncrun_state_CONTINUE after return it will be moved into queue <syncrun_qid_RUN> or queue <syncrun_qid_RUN2>.

static int execabort_syncrun( syncrun_t  * srun, enum  syncrun_qid_e  qid, uint16_t  entrysize )

Calls callabort_syncthread for every thread stored in queue qith id qid.  The parameter entrysize gives the size of an entry in the queue.  The initqueue is therefore not supported.  All queue entries are removed.  This function assumes that clearevents_syncrun has been called before.  If you abort threads stored in queue with qid <syncrun_qid_RUN2> or <syncrun_qid_WAIT2> other threads waiting for them to exit are not woken up.  Therefore execabort_syncrun is always called in the context of <abortall_syncrun>.

static int clearevents_syncrun( syncrun_t  * srun )

Set all <syncevent_t.waiting> pointer to 0 which reference threads in the wait queues.  This ensures that events do not referencewaiting threads after the waiting queues are freed.

static int test_run( void )

Test runall_syncrun with all possible state transitions.  All state transitions of a thread in every queue are tested.

static int test_run2( void )

Test correct variable values of a single thread in every posible state.