threads.h

Go to the documentation of this file.

/*
 * This file is part of the Ultibo project, https://ultibo.org/
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2026 Garry Wood <garry@softoz.com.au>
 *
 * 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 _ULTIBO_THREADS_H
#define _ULTIBO_THREADS_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include "ultibo/globaltypes.h"
#include "ultibo/globalconst.h"
#include "ultibo/system.h"
#include "ultibo/platform.h"
#include "ultibo/locale.h"


#define LOCK_FLAG_NONE  0x00000000
#define LOCK_FLAG_IRQ   0x00000001
#define LOCK_FLAG_FIQ   0x00000002
#define LOCK_FLAG_IRQFIQ    0x00000004

#define SPIN_SIGNATURE  0x0FEC3B82

#define SPIN_STATE_UNLOCKED 0
#define SPIN_STATE_LOCKED   1

#define MUTEX_SIGNATURE 0x1C5D7FA4

#define MUTEX_STATE_UNLOCKED    0
#define MUTEX_STATE_LOCKED  1

#define MUTEX_FLAG_NONE 0x00000000
#define MUTEX_FLAG_RECURSIVE    0x00000001 
#define MUTEX_FLAG_ERRORCHECK   0x00000002 

#define CRITICAL_SECTION_SIGNATURE  0x25F3AE01

#define CRITICAL_SECTION_STATE_UNLOCKED 0
#define CRITICAL_SECTION_STATE_LOCKED   1

#define SEMAPHORE_SIGNATURE 0x390A1EB4

#define SEMAPHORE_FLAG_NONE LOCK_FLAG_NONE
#define SEMAPHORE_FLAG_IRQ  LOCK_FLAG_IRQ
#define SEMAPHORE_FLAG_FIQ  LOCK_FLAG_FIQ
#define SEMAPHORE_FLAG_IRQFIQ   LOCK_FLAG_IRQFIQ

#define SYNCHRONIZER_SIGNATURE  0xC5D081FB

#define SYNCHRONIZER_STATE_UNLOCKED 0
#define SYNCHRONIZER_STATE_READER_LOCKED    1
#define SYNCHRONIZER_STATE_WRITER_LOCKED    2

#define SYNCHRONIZER_FLAG_NONE  0x00000000
#define SYNCHRONIZER_FLAG_READ_PRIORITY 0x00000001 
#define SYNCHRONIZER_FLAG_WRITE_PRIORITY    0x00000002 

#define CONDITION_SIGNATURE 0xD14D3C0A

#define CONDITION_FLAG_NONE 0x00000000

#define CONDITION_LOCK_FLAG_NONE    0x00000000
#define CONDITION_LOCK_FLAG_WRITER  0x00000001 

#define COMPLETION_SIGNATURE    0xFCE24CA1

#define COMPLETION_STATE_RESET  0
#define COMPLETION_STATE_COMPLETE   1

#define COMPLETION_FLAG_NONE    LOCK_FLAG_NONE
#define COMPLETION_FLAG_IRQ LOCK_FLAG_IRQ 
#define COMPLETION_FLAG_FIQ LOCK_FLAG_FIQ 
#define COMPLETION_FLAG_IRQFIQ  LOCK_FLAG_IRQFIQ 
#define COMPLETION_FLAG_COUNTED 0x00000008 

#define LIST_SIGNATURE  0x4A98BE2A

#define LIST_TYPE_NOT_SPECIFIED 0 
#define LIST_TYPE_WAIT_SECTION  1 
#define LIST_TYPE_WAIT_SEMAPHORE    2 
#define LIST_TYPE_WAIT_SYNCHRONIZER 3 
#define LIST_TYPE_WAIT_CONDITION    4 
#define LIST_TYPE_WAIT_COMPLETION   5 
#define LIST_TYPE_WAIT_EVENT    6 
#define LIST_TYPE_WAIT_THREAD   7 
#define LIST_TYPE_WAIT_MESSAGESLOT  8 
#define LIST_TYPE_WAIT_OTHER    9 

#define LIST_FLAG_NONE  LOCK_FLAG_NONE
#define LIST_FLAG_IRQ   LOCK_FLAG_IRQ
#define LIST_FLAG_FIQ   LOCK_FLAG_FIQ
#define LIST_FLAG_IRQFIQ    LOCK_FLAG_IRQFIQ

#define QUEUE_SIGNATURE 0x57A3BF9E

#define QUEUE_TYPE_NOT_SPECIFIED    0 
#define QUEUE_TYPE_SCHEDULE_SLEEP   1 
#define QUEUE_TYPE_SCHEDULE_TIMEOUT 2 
#define QUEUE_TYPE_SCHEDULE_TERMINATION 3 
#define QUEUE_TYPE_SCHEDULE_NONE    4 
#define QUEUE_TYPE_SCHEDULE_IDLE    5 
#define QUEUE_TYPE_SCHEDULE_LOWEST  6 
#define QUEUE_TYPE_SCHEDULE_LOWER   7 
#define QUEUE_TYPE_SCHEDULE_NORMAL  8 
#define QUEUE_TYPE_SCHEDULE_HIGHER  9 
#define QUEUE_TYPE_SCHEDULE_HIGHEST 10 
#define QUEUE_TYPE_SCHEDULE_CRITICAL    11 

#define QUEUE_FLAG_NONE LOCK_FLAG_NONE
#define QUEUE_FLAG_IRQ  LOCK_FLAG_IRQ
#define QUEUE_FLAG_FIQ  LOCK_FLAG_FIQ
#define QUEUE_FLAG_IRQFIQ   LOCK_FLAG_IRQFIQ
#define QUEUE_FLAG_DESCENDING   0x00000008
#define QUEUE_FLAG_DELTA    0x00000010

#define QUEUE_KEY_NONE  (int32_t)0x7FFFFFFF 
#define QUEUE_KEY_MAX   (int32_t)0x7FFFFFFE 
#define QUEUE_KEY_MIN   (int32_t)0x80000000 

#define THREAD_SIGNATURE    0x6C2BA10F

#define THREAD_TYPE_NORMAL  0 
#define THREAD_TYPE_IDLE    1 
#define THREAD_TYPE_IRQ 2 
#define THREAD_TYPE_FIQ 3 
#define THREAD_TYPE_SWI 4 

#define THREAD_FLAG_NONE    0x00000000
#define THREAD_FLAG_PERSIST 0x00000001 
#define THREAD_FLAG_CANCELLED   0x00000002 
#define THREAD_FLAG_CANCEL_DISABLE  0x00000004 
#define THREAD_FLAG_CANCEL_ASYNCHRONOUS 0x00000008 
 
#define THREAD_FLAG_INTERNAL    THREAD_FLAG_NONE + 0x80000000 

#define THREAD_STATE_RUNNING    1 
#define THREAD_STATE_READY  2 
#define THREAD_STATE_SLEEP  3 
#define THREAD_STATE_SUSPENDED  4 
#define THREAD_STATE_WAIT   5 
#define THREAD_STATE_WAIT_TIMEOUT   6 
#define THREAD_STATE_RECEIVE    7 
#define THREAD_STATE_RECEIVE_TIMEOUT    8 
#define THREAD_STATE_HALTED 9 
#define THREAD_STATE_TERMINATED 10 

#define THREAD_PRIORITY_NONE    0 
#define THREAD_PRIORITY_IDLE    1
#define THREAD_PRIORITY_LOWEST  2
#define THREAD_PRIORITY_LOWER   3
#define THREAD_PRIORITY_NORMAL  4
#define THREAD_PRIORITY_HIGHER  5
#define THREAD_PRIORITY_HIGHEST 6
#define THREAD_PRIORITY_CRITICAL    7
 
#define THREAD_PRIORITY_DEFAULT THREAD_PRIORITY_NORMAL 
#define THREAD_PRIORITY_MINIMUM THREAD_PRIORITY_IDLE 
#define THREAD_PRIORITY_MAXIMUM THREAD_PRIORITY_CRITICAL 
#define THREAD_PRIORITY_COUNT   THREAD_PRIORITY_MAXIMUM + 1 

#define THREAD_PRIORITY_BELOW_NORMAL    THREAD_PRIORITY_LOWER
#define THREAD_PRIORITY_ABOVE_NORMAL    THREAD_PRIORITY_HIGHER
#define THREAD_PRIORITY_TIME_CRITICAL   THREAD_PRIORITY_CRITICAL

#define THREAD_NAME_LENGTH  SIZE_64 
 
#define IRQ_THREAD_NAME "IRQ"
#define FIQ_THREAD_NAME "FIQ"
#define SWI_THREAD_NAME "SWI"
#define IDLE_THREAD_NAME    "Idle"
#define MAIN_THREAD_NAME    "Main"
#define TIMER_THREAD_NAME   "Timer"
#define WORKER_THREAD_NAME  "Worker"
#define TIMER_PRIORITY_THREAD_NAME  "Priority Timer"
#define WORKER_PRIORITY_THREAD_NAME "Priority Worker"
#define RTL_THREAD_NAME "RTL Thread"

#define TIMER_THREAD_PRIORITY   THREAD_PRIORITY_NORMAL
#define WORKER_THREAD_PRIORITY  THREAD_PRIORITY_NORMAL
#define TIMER_PRIORITY_THREAD_PRIORITY  THREAD_PRIORITY_HIGHEST
#define WORKER_PRIORITY_THREAD_PRIORITY THREAD_PRIORITY_HIGHER

#define THREAD_CREATE_NONE  0x00000000
#define THREAD_CREATE_SUSPENDED 0x00000004

#define THREAD_TLS_FREE 0x00000000
#define THREAD_TLS_USED 0x00000001
#define THREAD_TLS_INVALID  0xFFFFFFFF
 
#define THREAD_TLS_MAXIMUM  SIZE_64 

#define THREAD_TLS_FLAG_NONE    0x00000000
#define THREAD_TLS_FLAG_FREE    0x00000001 

#define THREAD_LISTS_MAXIMUM    SIZE_64 

#define MESSAGESLOT_SIGNATURE   0xB631CE4B

#define MESSAGESLOT_FLAG_NONE   LOCK_FLAG_NONE
#define MESSAGESLOT_FLAG_IRQ    LOCK_FLAG_IRQ
#define MESSAGESLOT_FLAG_FIQ    LOCK_FLAG_FIQ
#define MESSAGESLOT_FLAG_IRQFIQ LOCK_FLAG_IRQFIQ

#define MAILSLOT_SIGNATURE  0x7A409BF3

#define BUFFER_SIGNATURE    0x830BEA71

#define BUFFER_FLAG_NONE    0x00000000
#define BUFFER_FLAG_SHARED  0x00000001 

#define EVENT_SIGNATURE 0x903BA69D

#define EVENT_STATE_UNSIGNALED  0
#define EVENT_STATE_SIGNALED    1

#define EVENT_FLAG_NONE 0x00000000
#define EVENT_FLAG_INITIAL_STATE    0x00000001
#define EVENT_FLAG_MANUAL_RESET 0x00000002

#define TIMER_SIGNATURE 0xAB7E07FB

#define TIMER_STATE_DISABLED    0
#define TIMER_STATE_ENABLED 1

#define TIMER_FLAG_NONE 0x00000000
#define TIMER_FLAG_RESCHEDULE   0x00000001 
#define TIMER_FLAG_IMMEDIATE    0x00000002 
#define TIMER_FLAG_WORKER   0x00000004 
#define TIMER_FLAG_PRIORITY 0x00000008 

#define TIMER_KEY_NONE  (int32_t)0x7FFFFFFF 
#define TIMER_KEY_MAX   (int32_t)0x7FFFFFFE 
#define TIMER_KEY_MIN   (int32_t)0x80000000 

#define WORKER_SIGNATURE    0xEF6A901B

#define WORKER_FLAG_NONE    0x00000000
#define WORKER_FLAG_RESCHEDULE  0x00000001 
#define WORKER_FLAG_IMMEDIATE   0x00000002 
#define WORKER_FLAG_CANCEL  0x00000004 
#define WORKER_FLAG_NOFREE  0x00000008 
#define WORKER_FLAG_TERMINATE   0x00000010 
#define WORKER_FLAG_IRQ 0x00000020 
#define WORKER_FLAG_FIQ 0x00000040 
#define WORKER_FLAG_PRIORITY    0x00000080 
 
#define WORKER_FLAG_INTERNAL    WORKER_FLAG_CANCEL | WORKER_FLAG_NOFREE | WORKER_FLAG_TERMINATE | WORKER_FLAG_IRQ | WORKER_FLAG_FIQ 
 
#define WORKER_FLAG_EXCLUDED_IRQ    WORKER_FLAG_RESCHEDULE | WORKER_FLAG_IMMEDIATE 
#define WORKER_FLAG_EXCLUDED_FIQ    WORKER_FLAG_RESCHEDULE | WORKER_FLAG_IMMEDIATE 

#define TASKER_TASK_THREADSENDMESSAGE   1 
#define TASKER_TASK_MESSAGESLOTSEND 2 
#define TASKER_TASK_SEMAPHORESIGNAL 3 
#define TASKER_TASK_COMPLETIONRESET 4 
#define TASKER_TASK_COMPLETIONCOMPLETE  5 

#define SCHEDULER_MIGRATION_DISABLED    0
#define SCHEDULER_MIGRATION_ENABLED 1

#define SCHEDULER_PREEMPT_DISABLED  0
#define SCHEDULER_PREEMPT_ENABLED   1

#define SCHEDULER_ALLOCATION_DISABLED   0
#define SCHEDULER_ALLOCATION_ENABLED    1

#define SCHEDULER_MASK_NONE (1 << THREAD_PRIORITY_NONE)
#define SCHEDULER_MASK_IDLE (1 << THREAD_PRIORITY_IDLE)
#define SCHEDULER_MASK_LOWEST   (1 << THREAD_PRIORITY_LOWEST)
#define SCHEDULER_MASK_LOWER    (1 << THREAD_PRIORITY_LOWER)
#define SCHEDULER_MASK_NORMAL   (1 << THREAD_PRIORITY_NORMAL)
#define SCHEDULER_MASK_HIGHER   (1 << THREAD_PRIORITY_HIGHER)
#define SCHEDULER_MASK_HIGHEST  (1 << THREAD_PRIORITY_HIGHEST)
#define SCHEDULER_MASK_CRITICAL (1 << THREAD_PRIORITY_CRITICAL)
 
static const uint32_t SCHEDULER_MASKS[THREAD_PRIORITY_COUNT] = {
  SCHEDULER_MASK_NONE,
  SCHEDULER_MASK_IDLE,
  SCHEDULER_MASK_LOWEST,
  SCHEDULER_MASK_LOWER,
  SCHEDULER_MASK_NORMAL,
  SCHEDULER_MASK_HIGHER,
  SCHEDULER_MASK_HIGHEST,
  SCHEDULER_MASK_CRITICAL};

#define SCHEDULER_QUANTUM_NONE  0
#define SCHEDULER_QUANTUM_IDLE  0
#define SCHEDULER_QUANTUM_LOWEST    1
#define SCHEDULER_QUANTUM_LOWER 2
#define SCHEDULER_QUANTUM_NORMAL    4
#define SCHEDULER_QUANTUM_HIGHER    6
#define SCHEDULER_QUANTUM_HIGHEST   8
#define SCHEDULER_QUANTUM_CRITICAL  10
 
static const uint32_t SCHEDULER_QUANTUMS[THREAD_PRIORITY_COUNT] = {
  SCHEDULER_QUANTUM_NONE,
  SCHEDULER_QUANTUM_IDLE,
  SCHEDULER_QUANTUM_LOWEST,
  SCHEDULER_QUANTUM_LOWER,
  SCHEDULER_QUANTUM_NORMAL,
  SCHEDULER_QUANTUM_HIGHER,
  SCHEDULER_QUANTUM_HIGHEST,
  SCHEDULER_QUANTUM_CRITICAL};



typedef struct _SPIN_ENTRY SPIN_ENTRY;
struct _SPIN_ENTRY
{
    // Spin Properties
    uint32_t signature; 
    uint32_t state; 
    uint32_t mask; 
    THREAD_HANDLE owner; 
    // Internal Properties
    SPIN_ENTRY *prev; 
    SPIN_ENTRY *next; 
    // Statistics Properties
};

typedef struct _MUTEX_ENTRY MUTEX_ENTRY;
struct _MUTEX_ENTRY
{
    // Mutex Properties
    uint32_t signature; 
    uint32_t state; 
    THREAD_HANDLE owner; 
    thread_yield_proc yield; 
    uint32_t count; 
    uint32_t flags; 
    uint32_t spincount; 
    // Internal Properties
    MUTEX_ENTRY *prev; 
    MUTEX_ENTRY *next; 
    // Statistics Properties
};

typedef struct _CRITICAL_SECTION_ENTRY CRITICAL_SECTION_ENTRY;
struct _CRITICAL_SECTION_ENTRY
{
    // Critical Section Properties
    uint32_t signature; 
    uint32_t state; 
    uint32_t count; 
    THREAD_HANDLE owner; 
    uint32_t spincount; 
    SPIN_HANDLE lock; 
    LIST_HANDLE list; 
    thread_wait_proc wait; 
    thread_wait_ex_proc waitex; 
    thread_release_proc release; 
    thread_abandon_proc abandon; 
    // Internal Properties
    CRITICAL_SECTION_ENTRY *prev; 
    CRITICAL_SECTION_ENTRY *next; 
    // Statistics Properties
};

typedef struct _SEMAPHORE_ENTRY SEMAPHORE_ENTRY;
struct _SEMAPHORE_ENTRY
{
    // Semaphore Properties
    uint32_t signature; 
    uint32_t count; 
    uint32_t maximum; 
    uint32_t flags; 
    SPIN_HANDLE lock; 
    LIST_HANDLE list; 
    thread_wait_proc wait; 
    thread_wait_ex_proc waitex; 
    thread_release_proc release; 
    thread_abandon_proc abandon; 
    // Internal Properties
    SEMAPHORE_ENTRY *prev; 
    SEMAPHORE_ENTRY *next; 
    // Statistics Properties
};

typedef struct _SYNCHRONIZER_ENTRY SYNCHRONIZER_ENTRY;
struct _SYNCHRONIZER_ENTRY
{
    // Synchronizer Properties
    uint32_t signature; 
    uint32_t state; 
    SPIN_HANDLE lock; 
    uint32_t readercount; 
    uint32_t writercount; 
    THREAD_HANDLE readerlast; 
    THREAD_HANDLE writerowner; 
    LIST_HANDLE readerlist; 
    LIST_HANDLE writerlist; 
    thread_wait_proc wait; 
    thread_wait_ex_proc waitex; 
    thread_release_proc release; 
    thread_abandon_proc abandon; 
    // Internal Properties
    SYNCHRONIZER_ENTRY *prev; 
    SYNCHRONIZER_ENTRY *next; 
    // Statistics Properties
};

typedef struct _CONDITION_ENTRY CONDITION_ENTRY;
struct _CONDITION_ENTRY
{
    // Condition Properties
    uint32_t signature; 
    uint32_t flags; 
    SPIN_HANDLE lock; 
    LIST_HANDLE list; 
    thread_wait_proc wait; 
    thread_wait_ex_proc waitex; 
    thread_release_proc release; 
    thread_abandon_proc abandon; 
    // Internal Properties
    CONDITION_ENTRY *prev; 
    CONDITION_ENTRY *next; 
    // Statistics Properties
};

typedef struct _COMPLETION_ENTRY COMPLETION_ENTRY;
struct _COMPLETION_ENTRY
{
    // Completion Properties
    uint32_t signature; 
    uint32_t state; 
    uint32_t count; 
    uint32_t flags; 
    SPIN_HANDLE lock; 
    LIST_HANDLE list; 
    thread_wait_proc wait; 
    thread_wait_ex_proc waitex; 
    thread_release_proc release; 
    thread_abandon_proc abandon; 
    // Internal Properties
    COMPLETION_ENTRY *prev; 
    COMPLETION_ENTRY *next; 
    // Statistics Properties
};

typedef struct _LIST_ELEMENT LIST_ELEMENT;
typedef struct _LIST_ENTRY LIST_ENTRY;
struct _LIST_ENTRY
{
    // List Properties
    uint32_t signature; 
    uint32_t listtype; 
    uint32_t count; 
    uint32_t flags; 
    SPIN_HANDLE lock; 
    LIST_ELEMENT *first; 
    LIST_ELEMENT *last; 
    // Internal Properties
    LIST_ENTRY *prev; 
    LIST_ENTRY *next; 
    // Statistics Properties
};

struct _LIST_ELEMENT
{
    THREAD_HANDLE thread; 
    LIST_ELEMENT *prev; 
    LIST_ELEMENT *next; 
};

typedef LIST_HANDLE LIST_HANDLES[THREAD_LISTS_MAXIMUM];

typedef struct _QUEUE_ELEMENT QUEUE_ELEMENT;
typedef struct _QUEUE_ENTRY QUEUE_ENTRY;
struct _QUEUE_ENTRY
{
    // Queue Properties
    uint32_t signature; 
    uint32_t queuetype; 
    uint32_t count; 
    uint32_t flags; 
    SPIN_HANDLE lock; 
    QUEUE_ELEMENT *first; 
    QUEUE_ELEMENT *last; 
    // Internal Properties
    QUEUE_ENTRY *prev; 
    QUEUE_ENTRY *next; 
    // Statistics Properties
};

struct _QUEUE_ELEMENT
{
    int key; 
    THREAD_HANDLE thread; 
    QUEUE_ELEMENT *prev; 
    QUEUE_ELEMENT *next; 
};

typedef struct _THREAD_MESSAGE THREAD_MESSAGE;
typedef struct _MESSAGE_LIST MESSAGE_LIST;
struct _MESSAGE_LIST
{
    // Header Properties
    uint32_t maximum; 
    uint32_t count; 
    uint32_t start; 
    // Internal Properties
    THREAD_MESSAGE *list; 
    // Statistics Properties
};

struct _THREAD_MESSAGE
{
    size_t msg;
    size_t wparam;
    ssize_t lparam;
    uint32_t time;
};

typedef struct _THREAD_ENTRY THREAD_ENTRY;
struct _THREAD_ENTRY
{
    // Thread Properties
    uint32_t signature; 
    uint32_t state; 
    uint32_t flags; 
    uint32_t priority; 
    uint32_t affinity; 
    void *stackbase; 
    uint32_t stacksize; 
    char name[THREAD_NAME_LENGTH]; 
    SPIN_HANDLE lock; 
    THREAD_HANDLE parent; 
    MESSAGE_LIST messages; 
    void *tlspointer; 
    void *tlstable[THREAD_TLS_MAXIMUM]; 
    uint32_t tlsflags[THREAD_TLS_MAXIMUM]; 
    uint32_t exitcode; 
    uint32_t lasterror; 
    LCID locale; 
    // Internal Properties
    uint32_t currentcpu; 
    void *stackpointer; 
    uint32_t targetcpu; 
    uint32_t targetpriority; 
    LIST_HANDLE list; 
    LIST_HANDLE waitlist; 
    LIST_HANDLES *waitlists; 
    uint32_t waitresult; 
    uint32_t receiveresult; 
    QUEUE_HANDLE schedulequeue; 
    LIST_ELEMENT listelement; 
    QUEUE_ELEMENT queueelement; 
    THREAD_ENTRY *prev; 
    THREAD_ENTRY *next; 
    // Statistics Properties
    int64_t createtime; 
    int64_t exittime; 
    int64_t kerneltime; 
    int64_t switchcount; 
};

typedef struct _THREAD_SNAPSHOT THREAD_SNAPSHOT;
struct _THREAD_SNAPSHOT
{
    // Snapshot Properties
    THREAD_HANDLE handle; 
    uint32_t state; 
    uint32_t flags; 
    uint32_t cpu; 
    uint32_t priority; 
    uint32_t affinity; 
    void *stackbase; 
    uint32_t stacksize; 
    void *stackpointer; 
    char name[THREAD_NAME_LENGTH]; 
    THREAD_HANDLE parent; 
    uint32_t exitcode; 
    uint32_t lasterror; 
    LCID locale; 
    uint32_t targetcpu; 
    uint32_t targetpriority; 
    int64_t createtime; 
    int64_t exittime; 
    int64_t kerneltime; 
    int64_t switchcount; 
    // Internal Properties
    THREAD_SNAPSHOT *next; 
};

typedef struct _MESSAGESLOT_ENTRY MESSAGESLOT_ENTRY;
struct _MESSAGESLOT_ENTRY
{
    // Messageslot Properties
    uint32_t signature; 
    uint32_t flags; 
    SPIN_HANDLE lock; 
    LIST_HANDLE list; 
    MESSAGE_LIST messages; 
    thread_wait_proc wait; 
    thread_wait_ex_proc waitex; 
    thread_release_proc release; 
    thread_abandon_proc abandon; 
    // Internal Properties
    MESSAGESLOT_ENTRY *prev; 
    MESSAGESLOT_ENTRY *next; 
    // Statistics Properties
};

typedef struct _MAILSLOT_ENTRY MAILSLOT_ENTRY;
struct _MAILSLOT_ENTRY
{
    // Mailslot Properties
    uint32_t signature; 
    uint32_t maximum; 
    uint32_t count; 
    uint32_t start; 
    SPIN_HANDLE lock; 
    SEMAPHORE_HANDLE sender; 
    SEMAPHORE_HANDLE receiver; 
    ssize_t *messages; 
    // Internal Properties
    MAILSLOT_ENTRY *prev; 
    MAILSLOT_ENTRY *next; 
    // Statistics Properties
};

typedef struct _BUFFER_ITEM BUFFER_ITEM;
typedef struct _BUFFER_ENTRY BUFFER_ENTRY;
struct _BUFFER_ENTRY
{
    // Buffer Properties
    uint32_t signature; 
    uint32_t size; 
    uint32_t count; 
    uint32_t flags; 
    SPIN_HANDLE lock; 
    SEMAPHORE_HANDLE available; 
    BUFFER_ITEM *buffers; 
    // Internal Properties
    BUFFER_ENTRY *prev; 
    BUFFER_ENTRY *next; 
    BUFFER_ITEM *first; 
    // Statistics Properties
};

struct _BUFFER_ITEM
{
    BUFFER_HANDLE parent; 
    BUFFER_ITEM *next; 
    void *buffer; 
    uint32_t reserved; 
};

typedef struct _EVENT_ENTRY EVENT_ENTRY;
struct _EVENT_ENTRY
{
    // Event Properties
    uint32_t signature; 
    uint32_t state; 
    uint32_t flags; 
    SPIN_HANDLE lock; 
    LIST_HANDLE list; 
    thread_wait_proc wait; 
    thread_wait_ex_proc waitex; 
    thread_release_proc release; 
    thread_abandon_proc abandon; 
    // Internal Properties
    EVENT_ENTRY *prev; 
    EVENT_ENTRY *next; 
    // Statistics Properties
};

typedef struct _TIMER_ITEM TIMER_ITEM;
typedef struct _TIMER_LIST TIMER_LIST;
struct _TIMER_LIST
{
    // List Properties
    uint32_t count; 
    uint32_t flags; 
    SPIN_HANDLE lock; 
    TIMER_ITEM *first; 
    TIMER_ITEM *last; 
    // Internal Properties
    // Statistics Properties
};

struct _TIMER_ITEM
{
    int key; 
    TIMER_HANDLE timer; 
    TIMER_ITEM *prev; 
    TIMER_ITEM *next; 
};

typedef struct _TIMER_ENTRY TIMER_ENTRY;
struct _TIMER_ENTRY
{
    // Timer Properties
    uint32_t signature; 
    uint32_t interval; 
    uint32_t state; 
    uint32_t flags; 
    SPIN_HANDLE lock; 
    timer_event_proc event; 
    void *data; 
    // Internal Properties
    TIMER_LIST *timerlist; 
    TIMER_ITEM timeritem; 
    TIMER_ENTRY *prev; 
    TIMER_ENTRY *next; 
    // Statistics Properties
};

typedef struct _WORKER_REQUEST WORKER_REQUEST;
struct _WORKER_REQUEST
{
    // Worker Properties
    uint32_t signature; 
    uint32_t interval; 
    uint32_t flags; 
    SPIN_HANDLE lock; 
    TIMER_HANDLE timer; 
    worker_task_proc task; 
    void *data; 
    worker_cb callback; 
};

typedef struct _TASKER_TASK TASKER_TASK;
typedef struct _TASKER_LIST TASKER_LIST;
struct _TASKER_LIST
{
    // List Properties
    uint32_t count; 
    SPIN_HANDLE lock; 
    TASKER_TASK *first; 
    TASKER_TASK *last; 
    // Internal Properties
    // Statistics Properties
};

struct _TASKER_TASK
{
    uint32_t task; 
    TASKER_TASK *prev; 
    TASKER_TASK *next; 
};

typedef struct _TASKER_THREAD_SEND_MESSAGE TASKER_THREAD_SEND_MESSAGE;
struct _TASKER_THREAD_SEND_MESSAGE
{
    uint32_t task; 
    TASKER_TASK *prev; 
    TASKER_TASK *next; 
    // Internal Properties
    THREAD_HANDLE thread; 
    THREAD_MESSAGE message; 
};

typedef struct _TASKER_MESSAGESLOT_SEND TASKER_MESSAGESLOT_SEND;
struct _TASKER_MESSAGESLOT_SEND
{
    uint32_t task; 
    TASKER_TASK *prev; 
    TASKER_TASK *next; 
    // Internal Properties
    MESSAGESLOT_HANDLE messageslot; 
    THREAD_MESSAGE message; 
};

typedef struct _TASKER_SEMAPHORE_SIGNAL TASKER_SEMAPHORE_SIGNAL;
struct _TASKER_SEMAPHORE_SIGNAL
{
    uint32_t task; 
    TASKER_TASK *prev; 
    TASKER_TASK *next; 
    // Internal Properties
    SEMAPHORE_HANDLE semaphore; 
    uint32_t count; 
};

typedef struct _TASKER_SEMAPHORE_RESET TASKER_SEMAPHORE_RESET;
struct _TASKER_SEMAPHORE_RESET
{
    uint32_t task; 
    TASKER_TASK *prev; 
    TASKER_TASK *next; 
    // Internal Properties
    COMPLETION_HANDLE completion; 
};

typedef struct _TASKER_SEMAPHORE_COMPLETE TASKER_SEMAPHORE_COMPLETE;
struct _TASKER_SEMAPHORE_COMPLETE
{
    uint32_t task; 
    TASKER_TASK *prev; 
    TASKER_TASK *next; 
    // Internal Properties
    COMPLETION_HANDLE completion; 
    LONGBOOL all; 
};

typedef ssize_t STDCALL (*thread_start_proc)(void *parameter);
typedef void STDCALL (*thread_end_proc)(uint32_t exitcode);


SPIN_HANDLE STDCALL spin_create(void);

SPIN_HANDLE STDCALL spin_create_ex(BOOL initialowner);

uint32_t STDCALL spin_destroy(SPIN_HANDLE spin);

THREAD_HANDLE STDCALL spin_owner(SPIN_HANDLE spin);

uint32_t STDCALL spin_lock(SPIN_HANDLE spin);

uint32_t STDCALL spin_unlock(SPIN_HANDLE spin);

uint32_t STDCALL spin_lock_irq(SPIN_HANDLE spin);

uint32_t STDCALL spin_unlock_irq(SPIN_HANDLE spin);

uint32_t STDCALL spin_lock_fiq(SPIN_HANDLE spin);

uint32_t STDCALL spin_unlock_fiq(SPIN_HANDLE spin);

uint32_t STDCALL spin_lock_irq_fiq(SPIN_HANDLE spin);

uint32_t STDCALL spin_unlock_irq_fiq(SPIN_HANDLE spin);

uint32_t STDCALL spin_lock_preempt(SPIN_HANDLE spin);

uint32_t STDCALL spin_unlock_preempt(SPIN_HANDLE spin);

BOOL STDCALL spin_check_irq(SPIN_HANDLE spin);

BOOL STDCALL spin_check_fiq(SPIN_HANDLE spin);

uint32_t STDCALL spin_exchange_irq(SPIN_HANDLE spin1, SPIN_HANDLE spin2);

uint32_t STDCALL spin_exchange_fiq(SPIN_HANDLE spin1, SPIN_HANDLE spin2);


MUTEX_HANDLE STDCALL mutex_create(void);

MUTEX_HANDLE STDCALL mutex_create_ex(BOOL initialowner, uint32_t spincount, uint32_t flags);

uint32_t STDCALL mutex_destroy(MUTEX_HANDLE mutex);

uint32_t STDCALL mutex_flags(MUTEX_HANDLE mutex);

uint32_t STDCALL mutex_count(MUTEX_HANDLE mutex);

THREAD_HANDLE STDCALL mutex_owner(MUTEX_HANDLE mutex);

uint32_t STDCALL mutex_lock(MUTEX_HANDLE mutex);

uint32_t STDCALL mutex_unlock(MUTEX_HANDLE mutex);

uint32_t STDCALL mutex_try_lock(MUTEX_HANDLE mutex);


CRITICAL_SECTION_HANDLE STDCALL critical_section_create(void);

CRITICAL_SECTION_HANDLE STDCALL critical_section_create_ex(BOOL initialowner, uint32_t spincount);

uint32_t STDCALL critical_section_destroy(CRITICAL_SECTION_HANDLE criticalsection);

uint32_t STDCALL critical_section_count(CRITICAL_SECTION_HANDLE criticalsection);

THREAD_HANDLE STDCALL critical_section_owner(CRITICAL_SECTION_HANDLE criticalsection);

uint32_t STDCALL critical_section_set_spin_count(CRITICAL_SECTION_HANDLE criticalsection, uint32_t spincount);

uint32_t STDCALL critical_section_lock(CRITICAL_SECTION_HANDLE criticalsection);

uint32_t STDCALL critical_section_lock_ex(CRITICAL_SECTION_HANDLE criticalsection, uint32_t timeout); 

uint32_t STDCALL critical_section_unlock(CRITICAL_SECTION_HANDLE criticalsection);

uint32_t STDCALL critical_section_try_lock(CRITICAL_SECTION_HANDLE criticalsection);


SEMAPHORE_HANDLE STDCALL semaphore_create(uint32_t count);

SEMAPHORE_HANDLE STDCALL semaphore_create_ex(uint32_t count, uint32_t maximum, uint32_t flags);

uint32_t STDCALL semaphore_destroy(SEMAPHORE_HANDLE semaphore);

uint32_t STDCALL semaphore_count(SEMAPHORE_HANDLE semaphore);

uint32_t STDCALL semaphore_wait(SEMAPHORE_HANDLE semaphore);

uint32_t STDCALL semaphore_wait_ex(SEMAPHORE_HANDLE semaphore, uint32_t timeout); 

uint32_t STDCALL semaphore_signal(SEMAPHORE_HANDLE semaphore);

uint32_t STDCALL semaphore_signal_ex(SEMAPHORE_HANDLE semaphore, uint32_t count, uint32_t *previous);


SYNCHRONIZER_HANDLE STDCALL synchronizer_create(void);

SYNCHRONIZER_HANDLE STDCALL synchronizer_create_ex(BOOL initialreader, BOOL initialwriter);

uint32_t STDCALL synchronizer_destroy(SYNCHRONIZER_HANDLE synchronizer);

uint32_t STDCALL synchronizer_reader_count(SYNCHRONIZER_HANDLE synchronizer);

THREAD_HANDLE STDCALL synchronizer_reader_last(SYNCHRONIZER_HANDLE synchronizer);

uint32_t STDCALL synchronizer_reader_lock(SYNCHRONIZER_HANDLE synchronizer);

uint32_t STDCALL synchronizer_reader_lock_ex(SYNCHRONIZER_HANDLE synchronizer, uint32_t timeout); 

uint32_t STDCALL synchronizer_reader_unlock(SYNCHRONIZER_HANDLE synchronizer);

uint32_t STDCALL synchronizer_reader_convert(SYNCHRONIZER_HANDLE synchronizer);

uint32_t STDCALL synchronizer_reader_convert_ex(SYNCHRONIZER_HANDLE synchronizer, uint32_t timeout); 

uint32_t STDCALL synchronizer_writer_count(SYNCHRONIZER_HANDLE synchronizer);

THREAD_HANDLE STDCALL synchronizer_writer_owner(SYNCHRONIZER_HANDLE synchronizer);

uint32_t STDCALL synchronizer_writer_lock(SYNCHRONIZER_HANDLE synchronizer);

uint32_t STDCALL synchronizer_writer_lock_ex(SYNCHRONIZER_HANDLE synchronizer, uint32_t timeout); 

uint32_t STDCALL synchronizer_writer_unlock(SYNCHRONIZER_HANDLE synchronizer);

uint32_t STDCALL synchronizer_writer_convert(SYNCHRONIZER_HANDLE synchronizer);


CONDITION_HANDLE STDCALL condition_create(void);

uint32_t STDCALL condition_destroy(CONDITION_HANDLE condition);

uint32_t STDCALL condition_wait(CONDITION_HANDLE condition, uint32_t timeout); 

uint32_t STDCALL condition_wait_mutex(CONDITION_HANDLE condition, MUTEX_HANDLE mutex, uint32_t timeout); 

uint32_t STDCALL condition_wait_synchronizer(CONDITION_HANDLE condition, SYNCHRONIZER_HANDLE synchronizer, uint32_t flags, uint32_t timeout); 

uint32_t STDCALL condition_wait_critical_section(CONDITION_HANDLE condition, CRITICAL_SECTION_HANDLE criticalsection, uint32_t timeout); 

uint32_t STDCALL condition_wake(CONDITION_HANDLE condition);

uint32_t STDCALL condition_wake_all(CONDITION_HANDLE condition);


COMPLETION_HANDLE STDCALL completion_create(uint32_t flags);

uint32_t STDCALL completion_destroy(COMPLETION_HANDLE completion);

uint32_t STDCALL completion_state(COMPLETION_HANDLE completion);

uint32_t STDCALL completion_wait(COMPLETION_HANDLE completion, uint32_t timeout);

uint32_t STDCALL completion_try_wait(COMPLETION_HANDLE completion);

uint32_t STDCALL completion_reset(COMPLETION_HANDLE completion);

uint32_t STDCALL completion_complete(COMPLETION_HANDLE completion);

uint32_t STDCALL completion_complete_all(COMPLETION_HANDLE completion);


LIST_HANDLE STDCALL list_create(void);

LIST_HANDLE STDCALL list_create_ex(uint32_t listtype, uint32_t flags);

uint32_t STDCALL list_destroy(LIST_HANDLE list);

uint32_t STDCALL list_count(LIST_HANDLE list);

uint32_t STDCALL list_add_first(LIST_HANDLE list, LIST_ELEMENT *element);

uint32_t STDCALL list_add_last(LIST_HANDLE list, LIST_ELEMENT *element);

LIST_ELEMENT * STDCALL list_get_thread(LIST_HANDLE list, THREAD_HANDLE thread);

LIST_ELEMENT * STDCALL list_get_first(LIST_HANDLE list);

LIST_ELEMENT * STDCALL list_get_first_ex(LIST_HANDLE list, BOOL remove);

LIST_ELEMENT * STDCALL list_get_last(LIST_HANDLE list);

LIST_ELEMENT * STDCALL list_get_last_ex(LIST_HANDLE list, BOOL remove);

uint32_t STDCALL list_insert(LIST_HANDLE list, LIST_ELEMENT *previous, LIST_ELEMENT *element);

uint32_t STDCALL list_remove(LIST_HANDLE list, LIST_ELEMENT *element);

BOOL STDCALL list_is_empty(LIST_HANDLE list);

BOOL STDCALL list_not_empty(LIST_HANDLE list);

uint32_t STDCALL list_lock(LIST_HANDLE list);

uint32_t STDCALL list_unlock(LIST_HANDLE list);


QUEUE_HANDLE STDCALL queue_create(void);

QUEUE_HANDLE STDCALL queue_create_ex(uint32_t queuetype, uint32_t flags);

uint32_t STDCALL queue_destroy(QUEUE_HANDLE queue);

uint32_t STDCALL queue_count(QUEUE_HANDLE queue);

uint32_t STDCALL queue_enqueue(QUEUE_HANDLE queue, THREAD_HANDLE thread);

THREAD_HANDLE STDCALL queue_dequeue(QUEUE_HANDLE queue);

int STDCALL queue_first_key(QUEUE_HANDLE queue);

int STDCALL queue_last_key(QUEUE_HANDLE queue);

uint32_t STDCALL queue_insert_key(QUEUE_HANDLE queue, THREAD_HANDLE thread, int key);

uint32_t STDCALL queue_delete_key(QUEUE_HANDLE queue, THREAD_HANDLE thread);

int STDCALL queue_increment_key(QUEUE_HANDLE queue);

int STDCALL queue_decrement_key(QUEUE_HANDLE queue);

BOOL STDCALL queue_is_empty(QUEUE_HANDLE queue);

BOOL STDCALL queue_not_empty(QUEUE_HANDLE queue);

uint32_t STDCALL queue_lock(QUEUE_HANDLE queue);

uint32_t STDCALL queue_unlock(QUEUE_HANDLE queue);


THREAD_HANDLE STDCALL thread_create(thread_start_proc startproc, uint32_t stacksize, uint32_t priority, const char *name, void *parameter);

THREAD_HANDLE STDCALL thread_create_ex(thread_start_proc startproc, uint32_t stacksize, uint32_t priority, uint32_t affinity, uint32_t cpu, const char *name, void *parameter);

uint32_t STDCALL thread_destroy(THREAD_HANDLE thread);

THREAD_HANDLE STDCALL thread_get_current(void);

uint32_t STDCALL thread_set_current(THREAD_HANDLE thread);

uint32_t STDCALL thread_get_name(THREAD_HANDLE thread, char *name, uint32_t len);

uint32_t STDCALL thread_set_name(THREAD_HANDLE thread, const char *name);

uint32_t STDCALL thread_get_cpu(THREAD_HANDLE thread);

uint32_t STDCALL thread_set_cpu(THREAD_HANDLE thread, uint32_t cpu);

uint32_t STDCALL thread_get_state(THREAD_HANDLE thread);

uint32_t STDCALL thread_get_flags(THREAD_HANDLE thread);

uint32_t STDCALL thread_set_flags(THREAD_HANDLE thread, uint32_t flags);

uint32_t STDCALL thread_add_flags(THREAD_HANDLE thread, uint32_t flags);

uint32_t STDCALL thread_remove_flags(THREAD_HANDLE thread, uint32_t flags);

LCID STDCALL thread_get_locale(THREAD_HANDLE thread);

uint32_t STDCALL thread_set_locale(THREAD_HANDLE thread, LCID locale);

uint32_t STDCALL thread_get_times(THREAD_HANDLE thread, int64_t *createtime, int64_t *exittime, int64_t *kerneltime);

uint32_t STDCALL thread_get_switch_count(THREAD_HANDLE thread, int64_t *switchcount);

uint32_t STDCALL thread_get_stack_free(void);

uint32_t STDCALL thread_get_stack_size(THREAD_HANDLE thread);

size_t STDCALL thread_get_stack_base(THREAD_HANDLE thread);

uint32_t STDCALL thread_set_stack_base(THREAD_HANDLE thread, size_t stackbase);

size_t STDCALL thread_get_stack_pointer(THREAD_HANDLE thread);

uint32_t STDCALL thread_get_exit_code(THREAD_HANDLE thread);

uint32_t STDCALL thread_get_affinity(THREAD_HANDLE thread);

uint32_t STDCALL thread_set_affinity(THREAD_HANDLE thread, uint32_t affinity);

uint32_t STDCALL thread_get_priority(THREAD_HANDLE thread);

uint32_t STDCALL thread_set_priority(THREAD_HANDLE thread, uint32_t priority);

uint32_t STDCALL thread_get_last_error(void);

void STDCALL thread_set_last_error(uint32_t lasterror);

uint32_t STDCALL thread_set_last_error_ex(uint32_t lasterror);

uint32_t STDCALL thread_get_wait_result(void);

uint32_t STDCALL thread_get_receive_result(void);

uint32_t STDCALL thread_get_tls_index(uint32_t tlsindex);

uint32_t STDCALL thread_alloc_tls_index(void);

uint32_t STDCALL thread_alloc_tls_index_ex(uint32_t flags);

uint32_t STDCALL thread_release_tls_index(uint32_t tlsindex);

void * STDCALL thread_get_tls_value(uint32_t tlsindex);

uint32_t STDCALL thread_set_tls_value(uint32_t tlsindex, void *tlsvalue);

void * STDCALL thread_get_tls_pointer(THREAD_HANDLE thread);

uint32_t STDCALL thread_set_tls_pointer(THREAD_HANDLE thread, void *tlspointer);

uint32_t STDCALL thread_ready(THREAD_HANDLE thread, BOOL reschedule);

uint32_t STDCALL thread_timeout(THREAD_HANDLE thread);

uint32_t STDCALL thread_wake(THREAD_HANDLE thread);

uint32_t STDCALL thread_migrate(THREAD_HANDLE thread, uint32_t cpu);

void STDCALL thread_end(uint32_t exitcode);

uint32_t STDCALL thread_halt(uint32_t exitcode);

uint32_t STDCALL thread_terminate(THREAD_HANDLE thread, uint32_t exitcode);

uint32_t STDCALL thread_yield(void);

uint32_t STDCALL thread_sleep(uint32_t milliseconds);

uint32_t STDCALL thread_wait(LIST_HANDLE list, SPIN_HANDLE lock, uint32_t flags);

uint32_t STDCALL thread_wait_ex(LIST_HANDLE list, SPIN_HANDLE lock, uint32_t flags, uint32_t timeout); 

uint32_t STDCALL thread_release(LIST_HANDLE list);

uint32_t STDCALL thread_abandon(LIST_HANDLE list);

uint32_t STDCALL thread_wait_terminate(THREAD_HANDLE thread, uint32_t timeout); 

uint32_t STDCALL thread_suspend(THREAD_HANDLE thread);

uint32_t STDCALL thread_resume(THREAD_HANDLE thread);

uint32_t STDCALL thread_wait_message(void);

uint32_t STDCALL thread_send_message(THREAD_HANDLE thread, THREAD_MESSAGE *message);

uint32_t STDCALL thread_receive_message(THREAD_MESSAGE *message);

uint32_t STDCALL thread_receive_message_ex(THREAD_MESSAGE *message, uint32_t timeout, BOOL remove); 

uint32_t STDCALL thread_abandon_message(THREAD_HANDLE thread);

uint32_t STDCALL thread_lock(THREAD_HANDLE thread);

uint32_t STDCALL thread_unlock(THREAD_HANDLE thread);


uint32_t STDCALL scheduler_check(uint32_t cpuid);

uint32_t STDCALL scheduler_wakeup(uint32_t cpuid);

uint32_t STDCALL scheduler_expire(uint32_t cpuid);

THREAD_HANDLE STDCALL scheduler_switch(uint32_t cpuid, THREAD_HANDLE thread);

THREAD_HANDLE STDCALL scheduler_select(uint32_t cpuid, THREAD_HANDLE thread, BOOL yield);

uint32_t STDCALL scheduler_reschedule(BOOL yield);

uint32_t STDCALL scheduler_migration_enable(void);

uint32_t STDCALL scheduler_migration_disable(void);

uint32_t STDCALL scheduler_preempt_enable(uint32_t cpuid);

uint32_t STDCALL scheduler_preempt_disable(uint32_t cpuid);

uint32_t STDCALL scheduler_allocation_enable(uint32_t cpuid);

uint32_t STDCALL scheduler_allocation_disable(uint32_t cpuid);


MESSAGESLOT_HANDLE STDCALL messageslot_create(void);

MESSAGESLOT_HANDLE STDCALL messageslot_create_ex(uint32_t maximum, uint32_t flags);

uint32_t STDCALL messageslot_destroy(MESSAGESLOT_HANDLE messageslot);

uint32_t STDCALL messageslot_count(MESSAGESLOT_HANDLE messageslot);

uint32_t STDCALL messageslot_send(MESSAGESLOT_HANDLE messageslot, THREAD_MESSAGE *message);

uint32_t STDCALL messageslot_receive(MESSAGESLOT_HANDLE messageslot, THREAD_MESSAGE *message);

uint32_t STDCALL messageslot_receive_ex(MESSAGESLOT_HANDLE messageslot, THREAD_MESSAGE *message, uint32_t timeout); 


MAILSLOT_HANDLE STDCALL mailslot_create(uint32_t maximum);

uint32_t STDCALL mailslot_destroy(MAILSLOT_HANDLE mailslot);

uint32_t STDCALL mailslot_count(MAILSLOT_HANDLE mailslot);

uint32_t STDCALL mailslot_send(MAILSLOT_HANDLE mailslot, ssize_t data);

uint32_t STDCALL mailslot_send_ex(MAILSLOT_HANDLE mailslot, ssize_t data, uint32_t timeout); 

ssize_t STDCALL mailslot_receive(MAILSLOT_HANDLE mailslot);

ssize_t STDCALL mailslot_receive_ex(MAILSLOT_HANDLE mailslot, uint32_t timeout); 


BUFFER_HANDLE STDCALL buffer_create(uint32_t size, uint32_t count);

BUFFER_HANDLE STDCALL buffer_create_ex(uint32_t size, uint32_t count, uint32_t flags);

uint32_t STDCALL buffer_destroy(BUFFER_HANDLE buffer);

uint32_t STDCALL buffer_count(BUFFER_HANDLE buffer);

uint32_t STDCALL buffer_available(BUFFER_HANDLE buffer);

void * STDCALL buffer_get(BUFFER_HANDLE buffer);

void * STDCALL buffer_get_ex(BUFFER_HANDLE buffer, uint32_t timeout); 

uint32_t STDCALL buffer_free(void *buffer);

void * STDCALL buffer_iterate(BUFFER_HANDLE buffer, void *previous);


EVENT_HANDLE STDCALL event_create(BOOL manualreset, BOOL initialstate);

EVENT_HANDLE STDCALL event_create_ex(uint32_t flags);

uint32_t STDCALL event_destroy(EVENT_HANDLE event);

uint32_t STDCALL event_state(EVENT_HANDLE event);

uint32_t STDCALL event_wait(EVENT_HANDLE event);

uint32_t STDCALL event_wait_ex(EVENT_HANDLE event, uint32_t timeout); 

uint32_t STDCALL event_set(EVENT_HANDLE event);

uint32_t STDCALL event_reset(EVENT_HANDLE event);

uint32_t STDCALL event_pulse(EVENT_HANDLE event);


TIMER_HANDLE STDCALL timer_create(uint32_t interval, BOOL enabled, BOOL reschedule, timer_event_proc event, void *data);

TIMER_HANDLE STDCALL timer_create_ex(uint32_t interval, uint32_t state, uint32_t flags, timer_event_proc event, void *data);

uint32_t STDCALL timer_destroy(TIMER_HANDLE timer);

uint32_t STDCALL timer_enable(TIMER_HANDLE timer);

uint32_t STDCALL timer_enable_ex(TIMER_HANDLE timer, uint32_t interval, timer_event_proc event, void *data);

uint32_t STDCALL timer_disable(TIMER_HANDLE timer);

TIMER_HANDLE STDCALL timer_dequeue(void);

int STDCALL timer_first_key(void);

uint32_t STDCALL timer_insert_key(TIMER_HANDLE timer, int key);

uint32_t STDCALL timer_delete_key(TIMER_HANDLE timer);

int STDCALL timer_decrement_key(void);

BOOL STDCALL timer_is_empty(void);

BOOL STDCALL timer_not_empty(void);

uint32_t STDCALL timer_check(void);

uint32_t STDCALL timer_trigger(void);


uint32_t STDCALL worker_schedule(uint32_t interval, worker_task_proc task, void *data, worker_cb callback);

WORKER_HANDLE STDCALL worker_schedule_ex(uint32_t interval, uint32_t flags, worker_task_proc task, void *data, worker_cb callback);

uint32_t STDCALL worker_cancel(WORKER_HANDLE worker);

uint32_t STDCALL worker_schedule_irq(uint32_t affinity, worker_task_proc task, void *data, worker_cb callback);

uint32_t STDCALL worker_schedule_irq_ex(uint32_t affinity, uint32_t flags, worker_task_proc task, void *data, worker_cb callback);

uint32_t STDCALL worker_schedule_fiq(uint32_t affinity, worker_task_proc task, void *data, worker_cb callback);

uint32_t STDCALL worker_schedule_fiq_ex(uint32_t affinity, uint32_t flags, worker_task_proc task, void *data, worker_cb callback);

uint32_t STDCALL worker_increase(uint32_t count);

uint32_t STDCALL worker_increase_ex(uint32_t count, BOOL priority);

uint32_t STDCALL worker_decrease(uint32_t count);

uint32_t STDCALL worker_decrease_ex(uint32_t count, BOOL priority);


uint32_t STDCALL tasker_thread_send_message(THREAD_HANDLE thread, THREAD_MESSAGE *message);

uint32_t STDCALL tasker_messageslot_send(MESSAGESLOT_HANDLE messageslot, THREAD_MESSAGE *message);

uint32_t STDCALL tasker_semaphore_signal(SEMAPHORE_HANDLE semaphore, uint32_t count);

uint32_t STDCALL tasker_completion_reset(COMPLETION_HANDLE completion);

uint32_t STDCALL tasker_completion_complete(COMPLETION_HANDLE completion, BOOL all);

uint32_t STDCALL tasker_enqueue(TASKER_TASK *task);

TASKER_TASK * STDCALL tasker_dequeue(void);

uint32_t STDCALL tasker_check(void);

uint32_t STDCALL tasker_trigger(void);


THREAD_ID STDCALL begin_thread(void *signalaction, size_t stacksize, thread_func threadfunction, void *threadparameter, uint32_t creationflags, THREAD_ID *threadid);

THREAD_ID STDCALL begin_thread_ex(void *signalaction, size_t stacksize, thread_func threadfunction, void *threadparameter, uint32_t creationflags, uint32_t priority, uint32_t affinity, uint32_t cpu, const char *name, THREAD_ID *threadid);

void STDCALL end_thread(uint32_t exitcode);


uint32_t STDCALL spin_get_count(void);

uint32_t STDCALL mutex_get_count(void);

uint32_t STDCALL critical_section_get_count(void);

uint32_t STDCALL semaphore_get_count(void);

uint32_t STDCALL synchronizer_get_count(void);

uint32_t STDCALL condition_get_count(void);

uint32_t STDCALL completion_get_count(void);

uint32_t STDCALL list_get_count(void);

uint32_t STDCALL queue_get_count(void);

uint32_t STDCALL thread_get_count(void);

uint32_t STDCALL thread_tls_get_count(void);

void * STDCALL thread_allocate_stack(uint32_t stacksize);

void STDCALL thread_release_stack(void *stackbase, uint32_t stacksize);
void * STDCALL thread_setup_stack(void *stackbase, thread_start_proc startproc, thread_end_proc returnproc, void *parameter);
 
THREAD_SNAPSHOT * STDCALL thread_snapshot_create(void);
uint32_t STDCALL thread_snapshot_destroy(THREAD_SNAPSHOT *snapshot);

uint32_t STDCALL messageslot_get_count(void);

uint32_t STDCALL mailslot_get_count(void);

uint32_t STDCALL buffer_get_count(void);

uint32_t STDCALL event_get_count(void);

uint32_t STDCALL timer_get_count(void);

uint32_t STDCALL worker_get_count(void);

uint32_t STDCALL worker_get_priority_count(void);

uint32_t STDCALL tasker_get_count(void);
 
uint32_t STDCALL list_type_to_string(uint32_t listtype, char *string, uint32_t len);
uint32_t STDCALL queue_type_to_string(uint32_t queuetype, char *string, uint32_t len);
uint32_t STDCALL thread_type_to_string(uint32_t threadtype, char *string, uint32_t len);
uint32_t STDCALL thread_state_to_string(uint32_t threadstate, char *string, uint32_t len);
uint32_t STDCALL thread_priority_to_string(uint32_t threadpriority, char *string, uint32_t len);


uint32_t STDCALL scheduler_get_list_flags(uint32_t listtype);

uint32_t STDCALL scheduler_get_queue_flags(uint32_t queuetype);

QUEUE_HANDLE STDCALL scheduler_get_queue_handle(uint32_t cpuid, uint32_t queuetype);

QUEUE_HANDLE STDCALL scheduler_get_queue_handle_ex(uint32_t cpuid, uint32_t priority);

uint32_t STDCALL scheduler_get_thread_count(uint32_t cpuid);

uint32_t STDCALL scheduler_get_thread_quantum(uint32_t cpuid);

THREAD_HANDLE STDCALL scheduler_get_thread_handle(uint32_t cpuid, uint32_t threadtype);

uint32_t STDCALL scheduler_get_priority_mask(uint32_t cpuid);

uint32_t STDCALL scheduler_get_priority_quantum(uint32_t priority);

uint32_t STDCALL scheduler_set_priority_quantum(uint32_t priority, uint32_t quantum);

uint32_t STDCALL scheduler_get_migration_quantum(void);

uint32_t STDCALL scheduler_get_starvation_quantum(uint32_t cpuid);

uint32_t STDCALL scheduler_get_thread_next(void);

uint32_t STDCALL scheduler_get_thread_migration(void);

uint32_t STDCALL scheduler_get_thread_preempt(uint32_t cpuid);

uint32_t STDCALL scheduler_get_thread_allocation(uint32_t cpuid);
 
uint32_t STDCALL scheduler_migration_to_string(uint32_t migration, char *string, uint32_t len);
uint32_t STDCALL scheduler_preempt_to_string(uint32_t preempt, char *string, uint32_t len);
uint32_t STDCALL scheduler_allocation_to_string(uint32_t allocation, char *string, uint32_t len);


uint32_t STDCALL timer_get_list_flags(void);

uint32_t STDCALL timer_get_messageslot_flags(void);


uint32_t STDCALL worker_get_messageslot_flags(void);
 
#ifdef __cplusplus
}
#endif
 
#endif // _ULTIBO_THREADS_H