stk_c.cpp File Reference

#include <cstddef>
#include <stk_config.h>
#include <stk.h>
#include <sync/stk_sync.h>
#include "stk_c.h"

Include dependency graph for stk_c.cpp:

Go to the source code of this file.

Classes
class	TaskWrapper
struct	stk_task_t
struct	TaskSlot

Macros
#define	STK_C_TASKS_MAX   (STK_C_KERNEL_MAX_TASKS)
#define	STK_KERNEL_CASE(X)

Functions
void *	operator new (std::size_t, void *ptr) noexcept
void	operator delete (void *, void *) noexcept
static stk_task_t *	AllocateTask (stk_task_entry_t entry, void *arg, stk_word_t *stack, uint32_t stack_size, EAccessMode mode)
static void	FreeTask (const stk_task_t *task)
stk_kernel_t *	stk_kernel_create (uint8_t core_nr)
	Create kernel.
void	stk_kernel_destroy (stk_kernel_t *k)
	Destroy dynamic kernel instance (only when not running).
void	stk_kernel_init (stk_kernel_t *k, uint32_t tick_period_us)
	Initialize kernel with given tick period.
void	stk_kernel_start (stk_kernel_t *k)
	Start the scheduler - never returns.
EKernelState	stk_kernel_get_state (const stk_kernel_t *k)
	Get state of the scheduler.
bool	stk_kernel_is_schedulable (const stk_kernel_t *k)
	Test whether currently configured task set is schedulable.
void	stk_kernel_add_task (stk_kernel_t *k, stk_task_t *task)
	Add task to non-HRT kernel (static or dynamic).
void	stk_kernel_remove_task (stk_kernel_t *k, stk_task_t *task)
	Remove finished task from dynamic kernel.
void	stk_kernel_add_task_hrt (stk_kernel_t *k, stk_task_t *task, int32_t periodicity_ticks, int32_t deadline_ticks, int32_t start_delay_ticks)
	Add task with HRT timing parameters (HRT kernels only).
stk_task_t *	stk_task_create_privileged (stk_task_entry_t entry, void *arg, stk_word_t *stack, uint32_t stack_size)
	Create privileged-mode (kernel-mode) task.
stk_task_t *	stk_task_create_user (stk_task_entry_t entry, void *arg, stk_word_t *stack, uint32_t stack_size)
	Create user-mode task.
void	stk_task_set_weight (stk_task_t *task, uint32_t weight)
	Set task weight (used only by Smooth Weighted Round Robin).
void	stk_task_set_priority (stk_task_t *task, uint8_t priority)
	Set task priority (used only by Fixed Priority scheduler).
void	stk_task_set_id (stk_task_t *task, uint32_t tid)
	Assign application-defined task ID (for tracing/debugging).
void	stk_task_set_name (stk_task_t *task, const char *tname)
	Assign human-readable task name (for tracing/debugging).
void	stk_task_destroy (stk_task_t *task)
	Destroy dynamically created task object.
stk_tid_t	stk_tid (void)
	Returns current task/thread ID (the value set by stk_task_set_id).
int64_t	stk_ticks (void)
	Returns number of ticks elapsed since kernel start.
int32_t	stk_tick_resolution (void)
	Returns how many microseconds correspond to one kernel tick.
int64_t	stk_time_now_ms (void)
	Returns current time in milliseconds since kernel start.
int64_t	stk_ticks_from_ms (int64_t msec)
	Get ticks from milliseconds using current kernel tick resolution.
void	stk_delay (uint32_t ticks)
	Busy-wait delay (other tasks continue to run).
void	stk_sleep (uint32_t ticks)
	Put current task to sleep (non-HRT kernels only).
void	stk_delay_ms (uint32_t ms)
	Busy-wait delay (other tasks continue to run).
void	stk_sleep_ms (uint32_t ms)
	Put current task to sleep (non-HRT kernels only).
void	stk_sleep_until (int64_t ts)
	Put current task to sleep (non-HRT kernels only).
void	stk_yield (void)
	Voluntarily give up CPU to another ready task (cooperative yield).
void *	stk_tls_get (void)
	Get thread-local pointer (platform-specific slot).
void	stk_tls_set (void *ptr)
	Set thread-local pointer.
void	stk_critical_section_enter (void)
	Enter critical section — disable context switches on current core.
void	stk_critical_section_exit (void)
	Leave critical section — re-enable context switches.

Variables
static volatile bool	s_TaskPoolLock = false
static TaskSlot	s_Tasks [(STK_C_KERNEL_MAX_TASKS)]

Macro Definition Documentation

STK_C_TASKS_MAX

#define STK_C_TASKS_MAX   (STK_C_KERNEL_MAX_TASKS)

Definition at line 17 of file stk_c.cpp.

Referenced by AllocateTask(), and FreeTask().

STK_KERNEL_CASE

#define STK_KERNEL_CASE

(

X

)

Value:

    case X: \
    { \
        static_assert(sizeof(STK_C_KERNEL_TYPE_CPU_##X) % sizeof(stk_word_t) == 0, \
                      "Kernel memory size must be multiple of stk_word_t"); \
        alignas(alignof(STK_C_KERNEL_TYPE_CPU_##X)) /* instead of __stk_c_stack_attr */ \
        static stk_word_t kernel_##X##_mem[sizeof(STK_C_KERNEL_TYPE_CPU_##X) / sizeof(stk_word_t)]; \
        IKernel *kernel = new (kernel_##X##_mem) STK_C_KERNEL_TYPE_CPU_##X(); \
        return reinterpret_cast<stk_kernel_t *>(kernel); \
    }

Definition at line 142 of file stk_c.cpp.

#define STK_KERNEL_CASE(X) \
    case X: \
    { \
        static_assert(sizeof(STK_C_KERNEL_TYPE_CPU_##X) % sizeof(stk_word_t) == 0, \
                      "Kernel memory size must be multiple of stk_word_t"); \
        alignas(alignof(STK_C_KERNEL_TYPE_CPU_##X)) /* instead of __stk_c_stack_attr */ \
        static stk_word_t kernel_##X##_mem[sizeof(STK_C_KERNEL_TYPE_CPU_##X) / sizeof(stk_word_t)]; \
        IKernel *kernel = new (kernel_##X##_mem) STK_C_KERNEL_TYPE_CPU_##X(); \
        return reinterpret_cast<stk_kernel_t *>(kernel); \
    }

Referenced by stk_kernel_create().

Function Documentation

AllocateTask()

stk_task_t * AllocateTask ( stk_task_entry_t entry, void * arg, stk_word_t * stack, uint32_t stack_size, EAccessMode mode )

static

Definition at line 92 of file stk_c.cpp.

{
    stk_task_t *task = nullptr;
 
    sync::ScopedCriticalSection __cs;
 
    for (uint32_t i = 0; i < STK_C_TASKS_MAX; ++i)
    {
        if (!s_Tasks[i].busy)
        {
            s_Tasks[i].busy = true;
 
            task = &s_Tasks[i].task;
            task->handle.Initialize(entry, arg, stack, stack_size, mode);
            break;
        }
    }
 
    STK_ASSERT(task != nullptr);
    return task;
}

References stk_task_t::handle, TaskWrapper::Initialize(), s_Tasks, STK_ASSERT, and STK_C_TASKS_MAX.

Referenced by stk_task_create_privileged(), and stk_task_create_user().

Here is the call graph for this function:

Here is the caller graph for this function:

FreeTask()

void FreeTask ( const stk_task_t * task )

static

Definition at line 118 of file stk_c.cpp.

{
    sync::ScopedCriticalSection __cs;
 
    for (uint32_t i = 0; i < STK_C_TASKS_MAX; ++i)
    {
        if (s_Tasks[i].busy && (task == &s_Tasks[i].task))
        {
            s_Tasks[i].busy = false;
            return;
        }
    }
 
    STK_ASSERT(false);
}

References s_Tasks, STK_ASSERT, and STK_C_TASKS_MAX.

Referenced by stk_task_destroy().

Here is the caller graph for this function:

operator delete()

void operator delete ( void * , void *  )

inlinenoexcept

Definition at line 20 of file stk_c.cpp.

{ /* nothing for placement delete */ }

operator new()

void * operator new ( std::size_t , void * ptr )

inlinenoexcept

Definition at line 19 of file stk_c.cpp.

{ return ptr; }

Variable Documentation

s_TaskPoolLock

volatile bool s_TaskPoolLock = false

static

Definition at line 85 of file stk_c.cpp.

s_Tasks

TaskSlot s_Tasks[(STK_C_KERNEL_MAX_TASKS)]

static

Definition at line 86 of file stk_c.cpp.

Referenced by AllocateTask(), and FreeTask().