#include <cstddef>
#include "stk.h"
#include "sync/stk_sync.h"
#include "memory/stk_memory.h"
#include "stk_c.h"
#include "stk_c_time.h"
#include "time/stk_time.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
class	EventOverrider
struct	KernelRegistryEntry

Namespaces
namespace	stk
	Namespace of STK package.
namespace	stk::interop_c_helper

Macros
#define	STK_TIMER_COUNT_MAX (STK_C_TIMER_MAX)
#define	STK_C_TASKS_MAX (STK_C_KERNEL_MAX_TASKS)
#define	STK_PP_CAT(A, B)
#define	STK_PP_CAT_EXPAND(A, B)
#define	STK_KERNEL_TYPE(X)
#define	STK_KERNEL_MEM(X)
#define	STK_KERNEL_CASE(X)

Functions
static IKernel *	CastCToKernelInterface (stk_kernel_t *const k)
static const IKernel *	CastCToKernelInterfaceConst (const stk_kernel_t *const k)
static stk_kernel_t *	CastCppKernelInterfaceToC (IKernel *const k)
void	stk::interop_c_helper::InitializeTimerHost (stk_kernel_t kernel, stk::time::TimerHost th, EAccessMode amode)
static void	FreeTask (const stk_task_t *tsk)
static stk_task_t *	CastCppTaskInterfaceToC (ITask *const t)
static void	RegisterKernel (IKernel *k, uint8_t core_nr)
static void	UnregisterKernel (const IKernel *k)
static void	SetEventOverrider (IKernel k, stk_event_overrider_t overrider)
static stk_task_t *	AllocateTask (stk_task_entry_t entry, void arg, stk_word_t stack, uint32_t stack_size, EAccessMode amode)
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.
stk_kernel_state_t	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 tsk)
	Add task to non-HRT kernel (static or dynamic).
void	stk_kernel_remove_task (stk_kernel_t k, stk_task_t tsk)
	Remove finished task from dynamic kernel.
bool	stk_kernel_is_started (const stk_kernel_t *k)
	Check whether the scheduler is currently running (first task switch has occurred).
void	stk_kernel_schedule_task_removal (stk_kernel_t k, stk_task_t tsk)
	Schedule removal of a running task from the kernel on the next tick.
void	stk_kernel_suspend_task (stk_kernel_t k, stk_task_t tsk, bool *suspended)
	Suspend a task (prevent it from being scheduled).
void	stk_kernel_resume_task (stk_kernel_t k, stk_task_t tsk)
	Resume a previously suspended task.
size_t	stk_kernel_enumerate_tasks (stk_kernel_t k, stk_task_t *tasks, size_t max_count)
	Enumerate all currently active tasks.
stk_timeout_t	stk_kernel_suspend (stk_kernel_t *k)
	Suspend scheduling (tickless idle entry point).
void	stk_kernel_resume (stk_kernel_t *k, stk_timeout_t elapsed_ticks)
	Resume scheduling after a prior stk_kernel_suspend() call.
void	stk_kernel_process_tick (stk_kernel_t *k)
	Manually deliver one scheduler tick to the kernel.
void	stk_kernel_process_hard_fault (stk_kernel_t *k)
	Trigger a kernel hard fault (safe-state handler).
void	stk_kernel_set_event_overrider (stk_kernel_t k, stk_event_overrider_t overrider)
	Install a platform event overrider on the kernel.
void	stk_kernel_add_task_hrt (stk_kernel_t k, stk_task_t tsk, 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 *tsk, stk_weight_t weight)
	Set task weight (used only by Smooth Weighted Round Robin).
void	stk_task_set_priority (stk_task_t *tsk, uint8_t priority)
	Set task priority (used only by Fixed Priority scheduler).
void	stk_task_set_name (stk_task_t tsk, const char tname)
	Assign human-readable task name (for tracing/debugging).
const char *	stk_task_get_name (const stk_task_t *tsk)
	Get human-readable task name previously set with stk_task_set_name().
stk_tid_t	stk_task_get_id (const stk_task_t *tsk)
	Get the unique identifier of a task.
void	stk_task_destroy (stk_task_t *tsk)
	Destroy dynamically created task object.
stk_tid_t	stk_tid (void)
	Returns current task/thread ID (the value set by stk_task_set_id).
stk_tick_t	stk_ticks (void)
	Returns number of ticks elapsed since kernel start.
uint32_t	stk_tick_resolution (void)
	Returns how many microseconds correspond to one kernel tick.
stk_time_t	stk_time_now_ms (void)
	Returns current time in milliseconds since kernel start.
stk_tick_t	stk_ticks_from_ms (stk_time_t msec)
	Get ticks from milliseconds using current kernel tick resolution.
stk_cycle_t	stk_sys_timer_count (void)
	Get raw system timer counter value.
uint32_t	stk_sys_timer_frequency (void)
	Get system timer frequency in Hz.
stk_cycle_t	stk_hires_cycles (void)
	Get raw CPU cycle counter.
uint32_t	stk_hires_frequency (void)
	Get CPU clock frequency in Hz.
stk_tick_t	stk_hires_time_us (void)
	Get elapsed time in microseconds from the high-resolution clock.
void	stk_delay (stk_timeout_t ticks)
	Busy-wait delay (other tasks continue to run).
void	stk_sleep (stk_timeout_t ticks)
	Put current task to sleep (non-HRT kernels only).
void	stk_delay_ms (stk_timeout_t ms)
	Busy-wait delay (other tasks continue to run).
void	stk_sleep_ms (stk_timeout_t ms)
	Put current task to sleep (non-HRT kernels only).
bool	stk_sleep_until (stk_tick_t ts)
	Put current task to sleep (non-HRT kernels only).
void	stk_sleep_cancel (stk_tid_t tid)
	Cancel the sleep of a task, waking it immediately.
void	stk_yield (void)
	Voluntarily give up CPU to another ready task (cooperative yield).
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 struct TaskSlot	s_Tasks [((4))]
static KernelRegistryEntry	s_KernelMap [(1)]

Macro Definition Documentation

◆ STK_C_TASKS_MAX

#define STK_C_TASKS_MAX (STK_C_KERNEL_MAX_TASKS)

Definition at line 37 of file stk_c.cpp.

Referenced by AllocateTask(), FreeTask(), and stk_kernel_enumerate_tasks().

◆ STK_KERNEL_CASE

#define STK_KERNEL_CASE ( X )

Value:

case X: \
{ \
    using KernelType_ = STK_KERNEL_TYPE(X); \
    STK_STATIC_ASSERT_N(((sizeof(KernelType_) % sizeof(Word)) == 0U), \
                        "Kernel memory size must be multiple of Word"); \
    alignas(alignof(KernelType_)) \
    static Word STK_KERNEL_MEM(X)[sizeof(KernelType_) / sizeof(Word)]; \
    k = new (STK_KERNEL_MEM(X)) KernelType_(); \
    RegisterKernel(k, static_cast<uint8_t>(X)); \
    break; \
}

Definition at line 320 of file stk_c.cpp.

#define STK_KERNEL_CASE(X) \
    case X: \
    { \
        using KernelType_ = STK_KERNEL_TYPE(X); \
        STK_STATIC_ASSERT_N(((sizeof(KernelType_) % sizeof(Word)) == 0U), \
                            "Kernel memory size must be multiple of Word"); \
        alignas(alignof(KernelType_)) \
        static Word STK_KERNEL_MEM(X)[sizeof(KernelType_) / sizeof(Word)]; \
        k = new (STK_KERNEL_MEM(X)) KernelType_(); \
        RegisterKernel(k, static_cast<uint8_t>(X)); \
        break; \
    }

Referenced by stk_kernel_create().

◆ STK_KERNEL_MEM

#define STK_KERNEL_MEM ( X )

Value:

STK_PP_CAT_EXPAND(kernel_, STK_PP_CAT_EXPAND(X, _mem))

STK_PP_CAT_EXPAND

#define STK_PP_CAT_EXPAND(A, B)

Definition stk_c.cpp:317

Definition at line 319 of file stk_c.cpp.

◆ STK_KERNEL_TYPE

#define STK_KERNEL_TYPE ( X )

Value:

STK_PP_CAT(STK_C_KERNEL_TYPE_CPU_, X)

STK_PP_CAT

#define STK_PP_CAT(A, B)

Definition stk_c.cpp:316

Definition at line 318 of file stk_c.cpp.

◆ STK_PP_CAT

#define STK_PP_CAT	(		A,
			B )

Value:

A##B

Definition at line 316 of file stk_c.cpp.

◆ STK_PP_CAT_EXPAND

#define STK_PP_CAT_EXPAND	(		A,
			B )

Value:

STK_PP_CAT(A, B)

Definition at line 317 of file stk_c.cpp.

◆ STK_TIMER_COUNT_MAX

#define STK_TIMER_COUNT_MAX (STK_C_TIMER_MAX)

Definition at line 21 of file stk_c.cpp.

Function Documentation

◆ AllocateTask()

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

static

Definition at line 264 of file stk_c.cpp.

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

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:

◆ CastCppKernelInterfaceToC()

stk_kernel_t * CastCppKernelInterfaceToC ( IKernel *const k )

inlinestatic

Definition at line 55 of file stk_c.cpp.

{
    return reinterpret_cast<stk_kernel_t *>(reinterpret_cast<void *>(k));
}

References __stk_forceinline.

Referenced by stk_kernel_create().

Here is the caller graph for this function:

◆ CastCppTaskInterfaceToC()

stk_task_t * CastCppTaskInterfaceToC ( ITask *const t )

inlinestatic

Definition at line 142 of file stk_c.cpp.

{
    return reinterpret_cast<stk_task_t *>(reinterpret_cast<void *>(t));
}

References __stk_forceinline.

Referenced by TaskWrapper::OnExit(), and stk_kernel_enumerate_tasks().

Here is the caller graph for this function:

◆ CastCToKernelInterface()

IKernel * CastCToKernelInterface ( stk_kernel_t *const k )

inlinestatic

Definition at line 43 of file stk_c.cpp.

{
    return reinterpret_cast<IKernel *>(reinterpret_cast<void *>(k));
}

References __stk_forceinline.

Referenced by stk::interop_c_helper::InitializeTimerHost(), stk_kernel_add_task(), stk_kernel_add_task_hrt(), stk_kernel_destroy(), stk_kernel_enumerate_tasks(), stk_kernel_init(), stk_kernel_process_hard_fault(), stk_kernel_process_tick(), stk_kernel_remove_task(), stk_kernel_resume(), stk_kernel_resume_task(), stk_kernel_schedule_task_removal(), stk_kernel_set_event_overrider(), stk_kernel_start(), stk_kernel_suspend(), and stk_kernel_suspend_task().

Here is the caller graph for this function:

◆ CastCToKernelInterfaceConst()

const IKernel * CastCToKernelInterfaceConst ( const stk_kernel_t *const k )

inlinestatic

Definition at line 49 of file stk_c.cpp.

{
    return reinterpret_cast<const IKernel *>(reinterpret_cast<const void *>(k));
}

References __stk_forceinline.

Referenced by stk_kernel_get_state(), stk_kernel_is_schedulable(), and stk_kernel_is_started().

Here is the caller graph for this function:

◆ FreeTask()

void FreeTask ( const stk_task_t * tsk )

static

Definition at line 290 of file stk_c.cpp.

{
    bool found = false;
    
    const sync::ScopedCriticalSection __cs;
 
    for (uint32_t i = 0U; ((i < STK_C_TASKS_MAX) && !found); ++i)
    {
        if (s_Tasks[i].busy && (tsk == &s_Tasks[i].task))
        {
            s_Tasks[i].busy = false;
            found = true;
        }
    }
 
    STK_ASSERT(found);
}

References s_Tasks, STK_ASSERT, and STK_C_TASKS_MAX.

Referenced by TaskWrapper::OnExit(), and stk_task_destroy().

Here is the caller graph for this function:

◆ RegisterKernel()

void RegisterKernel	(	IKernel *	k,
		uint8_t	core_nr )

static

Definition at line 220 of file stk_c.cpp.

{
    STK_ASSERT(s_KernelMap[core_nr].kernel == nullptr);
 
    s_KernelMap[core_nr].kernel = k;
}

References s_KernelMap, and STK_ASSERT.

◆ SetEventOverrider()

void SetEventOverrider	(	IKernel *	k,
		stk_event_overrider_t *	overrider )

static

Definition at line 240 of file stk_c.cpp.

{
    bool found = false;
 
    for (uint32_t i = 0U; (i < STK_C_CPU_COUNT) && (!found); ++i)
    {
        if (s_KernelMap[i].kernel == k)
        {
            s_KernelMap[i].event_cb.SetCallback(overrider);
            k->GetPlatform()->SetEventOverrider(
                (overrider != nullptr) ? &s_KernelMap[i].event_cb : nullptr);
            found = true;
        }
    }
 
    // Kernel not found: stk_kernel_set_event_overrider() called before
    // stk_kernel_create() or after stk_kernel_destroy().
    STK_ASSERT(found);
}

References stk::IKernel::GetPlatform(), s_KernelMap, stk::IPlatform::SetEventOverrider(), STK_ASSERT, and STK_C_CPU_COUNT.

Referenced by stk_kernel_set_event_overrider().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UnregisterKernel()

void UnregisterKernel ( const IKernel * k )

static

Definition at line 227 of file stk_c.cpp.

{
    for (uint32_t i = 0U; i < STK_C_CPU_COUNT; ++i)
    {
        if (s_KernelMap[i].kernel == k)
        {
            s_KernelMap[i].event_cb.SetCallback(nullptr);
            s_KernelMap[i].kernel = nullptr;
            break;
        }
    }
}

References s_KernelMap, and STK_C_CPU_COUNT.

Referenced by stk_kernel_destroy().

Here is the caller graph for this function:

Variable Documentation

◆ s_KernelMap

KernelRegistryEntry s_KernelMap[(1)]

static

Definition at line 218 of file stk_c.cpp.

Referenced by RegisterKernel(), SetEventOverrider(), and UnregisterKernel().

◆ s_Tasks

struct TaskSlot s_Tasks[ ( (4) )]

static

Referenced by AllocateTask(), and FreeTask().

Classes

Namespaces

Macros

Functions

Variables

Macro Definition Documentation

◆ STK_C_TASKS_MAX

◆ STK_KERNEL_CASE

◆ STK_KERNEL_MEM

◆ STK_KERNEL_TYPE

◆ STK_PP_CAT

◆ STK_PP_CAT_EXPAND

◆ STK_TIMER_COUNT_MAX

Function Documentation

◆ AllocateTask()

◆ CastCppKernelInterfaceToC()

◆ CastCppTaskInterfaceToC()

◆ CastCToKernelInterface()

◆ CastCToKernelInterfaceConst()

◆ FreeTask()

◆ RegisterKernel()

◆ SetEventOverrider()

◆ UnregisterKernel()

Variable Documentation

◆ s_KernelMap

◆ s_Tasks