taskSch.h

Go to the documentation of this file.

/*
 *  Task scheduler for uniform task processing in user space.
 *  Copyright (C) 2015  Valdemar Lindberg
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
#ifndef _CORE_TASK_SCH_H_
#define _CORE_TASK_SCH_H_ 1
 
#include <stdint.h>
#include <stdlib.h>
 
#ifdef __cplusplus
#include <atomic>
using namespace std;
#else
#include <stdatomic.h>
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef TASH_SCH_EXTERN
#ifndef TASH_SCH_STATIC
#ifdef _WIN32
#define TASH_SCH_EXTERN __declspec(dllimport)
#elif defined(__GNUC__) && __GNUC__ >= 4 || __clang__
#define TASH_SCH_EXTERN __attribute__((visibility("default")))
#else
#define TASH_SCH_EXTERN
#endif
#else
#define TASH_SCH_EXTERN
#endif
#endif
 
#define SCH_FLAG_NO_AFM 0x80000000 /*  Disable affinity mapping one to one between core and task pools.    */
 
#define SCH_FLAG_INIT 0x1    /*  Scheduler has been initialized.    */
#define SCH_FLAG_RUNNING 0x2 /*  Scheduler is in running mode.   */
#define SCH_FLAG_IDLE 0x4    /* Scheduler is running, but waiting for tasks.    */
 
#define SCH_POOL_TERMINATE 0x1 /*  Pool has been terminated.   */
#define SCH_POOL_RUNNING 0x2   /*  Pool is in running mode.    */
#define SCH_POOL_SLEEP 0x4     /*  Pool is in sleep mode.  */
 
#define SCH_SIGNAL_IDLE (schBaseSignal() + 0)     /*  */
#define SCH_SIGNAL_RUNNING (schBaseSignal() + 1)  /*  */
#define SCH_SIGNAL_DONE (schBaseSignal() + 2)     /*  */
#define SCH_SIGNAL_CONTINUE (schBaseSignal() + 3) /*  */
#define SCH_SIGNAL_QUIT (schBaseSignal() + 4)     /*  */
#define SCH_SIGNAL_STOP SIGSTOP
 
enum SchErrCode {
    SCH_OK = 1,                          /*  No error.   */
    SCH_ERROR_UNKNOWN = 0,               /*  Error unknown.   */
    SCH_ERROR_INVALID_ARG = -1,          /*  Invalid argument.   */
    SCH_ERROR_INVALID_SCH = (-2),        /*  Invalid scheduler object.   */
    SCH_ERROR_INVALID_STATE = (-3),      /*  Scheduler/Pool in bad state.    */
    SCH_ERROR_INTERNAL = (-4),           /*  Internal error. */
    SCH_ERROR_POOL_FULL = (-5),          /*  Pool queue is full. */
    SCH_ERROR_SIGNAL = (-6),             /*  Signal failed.  */
    SCH_ERROR_SYNC_OBJECT = (-7),        /*  Synchronization object failed.   */
    SCH_ERROR_TIMEOUT = (-8),            /*  Timeout.    */
    SCH_ERROR_BUSY = (-9),               /*  Busy error. */
    SCH_ERROR_NOMEM = (-10),             /*  No Memory.  */
    SCH_ERROR_LACK_OF_RESOURCES = (-11), /*  There system is lacking resources.  */
    SCH_ERROR_PERMISSION_DENIED = (-12), /*  Permission denied of the operation. */
};
typedef void *(*schFunc)(void *pdata); /*  */
 
typedef void schSpinLock;    /* Spinlock sync object.   */
typedef void schMutex;       /* Mutex (mutual exclusion) sync object. */
typedef void schSemaphore;   /* Semaphore sync object.  */
typedef void schRWLock;      /*  Read/Write lock.   */
typedef void schConditional; /*  Conditional lock.  */
typedef void schBarrier;     /*  Memory Barrier.    */
typedef void schThread;    /*  Thread object.  */
typedef void schSignalSet; /*  Signal set object.  */
typedef struct sch_task_scheduler_t schTaskSch;
typedef struct sch_task_pool_t schTaskPool;
typedef struct sch_task_package_t schTaskPackage;
 
typedef int (*schUserCallBack)(struct sch_task_pool_t *);
typedef int (*schCallback)(schTaskPackage *package);
 
typedef struct sch_task_package_t {
    atomic_uint flag; /*     */
    unsigned int index;
    schCallback callback;
    size_t size;
    size_t offset;
    void *begin;
    void *end;
    void *puser;
} schTaskPackage;
 
extern TASH_SCH_EXTERN int schAllocateTaskPool(schTaskSch **pSch);
 
extern TASH_SCH_EXTERN int schCreateTaskPool(schTaskSch *sch, int cores, unsigned int flag,
                                             unsigned int maxPackagesPool);
 
extern TASH_SCH_EXTERN int schReleaseTaskSch(schTaskSch *sch);
 
extern TASH_SCH_EXTERN void schSetInitCallBack(schTaskSch *sch, schUserCallBack callBack);
 
extern TASH_SCH_EXTERN void schSetDeInitCallBack(schTaskSch *sch, schUserCallBack callBack);
 
extern TASH_SCH_EXTERN void schSetSchUserData(schTaskSch *sch, const void *user);
 
extern TASH_SCH_EXTERN void schSetPoolUserData(schTaskSch *sch, int index, const void *user);
 
extern TASH_SCH_EXTERN void *schGetPoolUserData(schTaskSch *sch, int index);
 
extern TASH_SCH_EXTERN schTaskPool *schGetPool(schTaskSch *sch, int index);
 
extern TASH_SCH_EXTERN int schRunTaskSch(schTaskSch *sch);
 
extern TASH_SCH_EXTERN int schStopTaskSch(schTaskSch *sch, long int timeout_nanoseconds);
 
extern TASH_SCH_EXTERN int schTerminateTaskSch(schTaskSch *sch); // TODO give timeout option perhaps.
 
extern TASH_SCH_EXTERN int schSubmitTask(schTaskSch *sch, schTaskPackage *package, schTaskPool *pPool);
 
extern TASH_SCH_EXTERN int schClearTask(schTaskSch *sch, schTaskPool *pool);
 
extern TASH_SCH_EXTERN int schClearAllTask(schTaskSch *sch);
 
extern TASH_SCH_EXTERN int schWaitTask(schTaskSch *sch);
 
extern TASH_SCH_EXTERN int schWaitTaskWait(schTaskSch *sch, long int wait_nanoseconds);
 
extern TASH_SCH_EXTERN int schPoolLock(schTaskPool *pool);
 
extern TASH_SCH_EXTERN int schPoolMutexUnLock(schTaskPool *pool);
 
extern TASH_SCH_EXTERN schThread *schCreateThread(int affinity, schFunc pfunc, void *userData);
 
extern TASH_SCH_EXTERN int schDeleteThread(schThread *thread);
 
extern TASH_SCH_EXTERN int schWaitThread(schThread *thread, void **retval);
 
extern TASH_SCH_EXTERN int schSetThreadName(schThread *thread, const char *name);
 
extern TASH_SCH_EXTERN schThread *schCurrentThread(void);
 
extern TASH_SCH_EXTERN int schRaiseThreadSignal(schThread *thread, int signal);
 
extern TASH_SCH_EXTERN schSignalSet *schCreateSignal(void);
 
extern TASH_SCH_EXTERN int schDeleteSignal(schSignalSet *signal);
 
extern TASH_SCH_EXTERN int schBaseSignal(void);
 
extern TASH_SCH_EXTERN int schSignalWait(schSignalSet *sig);
 
extern TASH_SCH_EXTERN int schSignalWaitTimeOut(schSignalSet *sig, long int nanoseconds);
 
extern TASH_SCH_EXTERN int schSetSignalThreadMask(schSignalSet *set, int nr, const int *signals);
 
extern TASH_SCH_EXTERN int schCreateMutex(schMutex **mutex);
 
extern TASH_SCH_EXTERN int schCreateSpinLock(schSpinLock **spinlock);
 
extern TASH_SCH_EXTERN int schCreateSemaphore(schSemaphore **pSemaphore);
 
extern TASH_SCH_EXTERN int schCreateBarrier(schBarrier **pBarrier);
 
extern TASH_SCH_EXTERN int schInitBarrier(schBarrier *pBarrier, int count);
 
extern TASH_SCH_EXTERN int schDeleteBarrier(schBarrier *barrier);
 
extern TASH_SCH_EXTERN int schWaitBarrier(schBarrier *barrier);
 
extern TASH_SCH_EXTERN int schCreateConditional(schConditional **pCondVariable);
 
extern TASH_SCH_EXTERN int schDeleteConditional(schConditional *conditional);
 
extern TASH_SCH_EXTERN int schConditionalWait(schConditional *conditional, schMutex *mutex);
 
extern TASH_SCH_EXTERN int schConditionalSignal(schConditional *conditional);
 
extern TASH_SCH_EXTERN int schCreateRWLock(schRWLock **pRwLock);
 
extern TASH_SCH_EXTERN int schDeleteRWLock(schRWLock *rwLock);
 
extern TASH_SCH_EXTERN int schRWLockRead(schRWLock *rwLock);
 
extern TASH_SCH_EXTERN int schRWLockWrite(schRWLock *rwLock);
 
extern TASH_SCH_EXTERN int schRWLocUnLock(schRWLock *rwLock);
 
extern TASH_SCH_EXTERN int schDeleteMutex(schMutex *mutex);
 
extern TASH_SCH_EXTERN int schDeleteSpinLock(schSpinLock *spinlock);
 
extern TASH_SCH_EXTERN int schDeleteSemaphore(schSemaphore *pSemaphore);
 
extern TASH_SCH_EXTERN int schMutexLock(schMutex *mutexLock);
 
extern TASH_SCH_EXTERN int schMutexTryLock(schMutex *mutex, long int timeout);
 
extern TASH_SCH_EXTERN int schMutexUnLock(schMutex *mutexLock);
 
extern TASH_SCH_EXTERN int schSemaphoreWait(schSemaphore *pSemaphore);
 
extern TASH_SCH_EXTERN int schSemaphoreTryWait(schSemaphore *semaphore);
 
extern TASH_SCH_EXTERN int schSemaphoreTimedWait(schSemaphore *pSemaphore, long int timeout);
 
extern TASH_SCH_EXTERN int schSemaphorePost(schSemaphore *pSemaphore);
 
extern TASH_SCH_EXTERN int schSemaphoreValue(schSemaphore *pSemaphore, int *value);
 
extern TASH_SCH_EXTERN int schLockSpinLock(schSpinLock *spinlock);
 
extern TASH_SCH_EXTERN int schTryLockSpinLock(schSpinLock *spinLock);
 
extern TASH_SCH_EXTERN int schUnlockSpinLock(schSpinLock *spinlock);
 
extern TASH_SCH_EXTERN const char *schErrorMsg(int errMsg);
 
#ifdef __cplusplus
}
#endif
 
#endif