OS Abstractions such as Mutexes, Semaphores and Threads. More...

Classes
class	AtomicInt
	C++ abstraction of atomic integer operations. More...
class	Condition
	An object oriented wrapper around a condition variable. More...
class	MainThread
	A class which represents the main() thread. More...
class	MutexInterface
	An interface to a Mutex. More...
class	Mutex
	An object oriented wrapper around a non recursive mutex. More...
class	MutexRecursive
	An object oriented wrapper around a recursive mutex. More...
class	MutexLock
	MutexLock is a scope based Monitor, protecting critical sections with a Mutex object through locking and unlocking it. More...
class	MutexTryLock
	A MutexTryLock tries to lock an Mutex object on construction and if successful, unlocks it on destruction of the MutexTryLock. More...
class	MutexTimedLock
	A MutexTimedLock locks a Mutex object on construction and if successful, unlocks it on destruction of the MutexTimedLock. More...
class	local_allocator
	A simple local allocator which keeps a small pool which you can grow manually with grow(). More...
class	rt_allocator
	A real-time malloc allocator which allocates every block with oro_rt_malloc() and deallocates with oro_rt_free(). More...
struct	rt_list
	Implements a list with real-time insertion/removal of elements. More...
class	streambufs
	A base class for all stream buffer operations. More...
class	stringbufs
	A streambufs implementation based on strings. More...
class	basic_streams
	This is a stream class for use in limited environments. More...
class	basic_istreams
	An basic_istream is a stream which can be read. More...
class	basic_ostreams
	An basic_ostreams is a stream which can be written to. More...
class	basic_iostreams
	An IO stream based on strings. More...
class	printstream
	The printstream is a stream for printing characters to the terminal window. More...
class	stringstreams
	Stringstreams, are not guaranteed to be hard realtime. More...
class	Semaphore
	An object oriented wrapper around a counting semaphore. More...
class	StartStopManager
	This manager starts and stops all globally registered start/stop functions, without a particular order. More...
struct	InitFunction
	Use this to register a global init function to the StartStopManager. More...
struct	CleanupFunction
	Use this to register a global cleanup function to the StartStopManager. More...
class	Thread
	A Thread object executes user code in its own thread. More...
class	ThreadInterface
	A thread which is being run. More...
class	Timer
	This class allows to define a timer object which can be armed in single shot and periodic mode. More...
class	TimeService
	The TimeService is used for system-wide time keeping and conversions. More...
Functions
template<class T , class V , class W >
bool	CAS (volatile T *addr, const V &expected, const W &value)
	Compare And Swap.
INTERNAL_QUAL int	rtos_task_create_main (RTOS_TASK *main_task)
	Initialise the main thread.
INTERNAL_QUAL int	rtos_task_delete_main (RTOS_TASK *main_task)
	Cleanup the main thread.
INTERNAL_QUAL int	rtos_task_create (RTOS_TASK task, int priority, unsigned cpu_affinity, const char name, int sched_type, size_t stack_size, void (start_routine)(void ), ThreadInterface obj)
	Create a thread.
INTERNAL_QUAL void	rtos_task_yield (RTOS_TASK *task)
	Yields the current thread.
INTERNAL_QUAL void	wakeup_handler (cyg_handle_t alarm_handle, cyg_addrword_t data)
INTERNAL_QUAL void	rtos_task_make_periodic (RTOS_TASK *mytask, NANO_TIME nanosecs)
	This function is to inform the RTOS that a thread is switching between periodic or non-periodic execution.
INTERNAL_QUAL int	rtos_task_check_priority (int sched_type, int priority)
	This function checks (and corrects) a given priority within a given scheduler type.
unsigned int	rtos_task_get_pid (const RTOS_TASK *task)
	Returns the process ID the OS gave to the task task.
int	rtos_task_set_scheduler (RTOS_TASK *t, int sched_type)
	Set the scheduler of a given task t to a the type sched_type.
int	rtos_task_get_scheduler (const RTOS_TASK *t)
	Returns the current scheduler set for task t.
void	rtos_task_set_period (RTOS_TASK *mytask, NANO_TIME nanosecs)
	Change the period of a periodic RTOS task.
void	rtos_task_set_wait_period_policy (RTOS_TASK *task, int policy)
	Set the wait policy of a thread.
int	rtos_task_wait_period (RTOS_TASK *task)
	This function is called by a periodic thread which wants to go to sleep and wake up the next period.
void	rtos_task_delete (RTOS_TASK *mytask)
	This function must join the thread created with rtos_task_create and then clean up the RTOS_TASK struct.
int	rtos_task_check_scheduler (int *sched_type)
	This function checks (and corrects) if the given sched_type is valid for this RTOS.
int	rtos_task_set_priority (RTOS_TASK *task, int priority)
	Set the priority of a thread.
int	rtos_task_get_priority (const RTOS_TASK *task)
	Return the priority of a thread.
int	rtos_task_set_cpu_affinity (RTOS_TASK *task, unsigned cpu_affinity)
	Set the cpu affinity of a thread.
unsigned	rtos_task_get_cpu_affinity (const RTOS_TASK *task)
	Return the cpu affinity of a thread.
const char *	rtos_task_get_name (const RTOS_TASK *task)
	Returns the name by which a task is known in the RTOS.
int	rtos_task_is_self (const RTOS_TASK *task)
	Returns 1 when task is the task struct of the thread calling this function, 0 otherwise.
INTERNAL_QUAL void *	rtos_posix_thread_wrapper (void *cookie)
INTERNAL_QUAL void *	rtai_thread_wrapper (void *arg)
template<class T , class A , class A2 >
bool	operator== (const local_allocator< T, A > &, const local_allocator< T, A2 > &)
template<class T , class A , class A2 >
bool	operator!= (const local_allocator< T, A > &, const local_allocator< T, A2 > &)
template<class T , class A >
bool	operator== (const local_allocator< T, A > &, const local_allocator< T, A > &)
template<class T , class A >
bool	operator!= (const local_allocator< T, A > &, const local_allocator< T, A > &)
template<class T >
bool	operator== (const rt_allocator< T > &, const rt_allocator< T > &)
template<class T >
bool	operator!= (const rt_allocator< T > &, const rt_allocator< T > &)
basic_ostreams &	endl (basic_ostreams &)
	Flush and newline.
void *	thread_function (void *t)
bool	CheckScheduler (int &sched_type)
	Check if the scheduler is a valid type in the current process and adapt to a valid value.
bool	CheckPriority (int &sched_type, int &priority)
	Check if the scheduler type and priority match and adapt to a valid value.
void	ErrorHandler (LPTSTR lpszFunction)
DWORD WINAPI	ThreadWrapper (void *threadData)
INTERNAL_QUAL NANO_TIME	rtos_task_get_period (const RTOS_TASK *t)
INTERNAL_QUAL void	rtos_xeno_thread_wrapper (void *cookie)
Variables
const int	LowestPriority = ORONUM_OS_RTOS_LOWEST_PRIORITY
	An integer denoting the lowest priority of the selected OS.
const int	HighestPriority = ORONUM_OS_RTOS_HIGHEST_PRIORITY
	An integer denoting the highest priority of the selected OS.
const int	IncreasePriority = -1
	An interval to be added 'n' times to LowestPriority to get an 'n' times higher priority.
printstream	cout
	Console Output.
AtomicInt	threads (0)
	The number of threads in addition to the main() thread.

Detailed Description

OS Abstractions such as Mutexes, Semaphores and Threads.

OS abstractions.

It is meant to group all packages which provide OS abstraction classes and functions in a realtime system. Examples are Threads, Mutexes and standard libraries.

Function Documentation

template<class T , class V , class W >

bool RTT::os::CAS	(	volatile T *	addr,
		const V &	expected,
		const W &	value
	)

Compare And Swap.

Also known as Compare Exchange (cmpxch). If addr contains expected, replace it with value, and return true. Otherwise, return false.

Definition at line 54 of file CAS.hpp.

References oro_cmpxchg().

Referenced by RTT::internal::ListLockFree< connection_t >::append(), RTT::internal::ListLockFree< connection_t >::clear(), RTT::internal::ListLockFree< connection_t >::delete_if(), RTT::internal::AtomicQueue< T >::dequeue(), RTT::internal::AtomicQueue< T >::enqueue(), RTT::internal::ListLockFree< connection_t >::erase(), and RTT::internal::ListLockFree< connection_t >::reserve().

bool RTT_API RTT::os::CheckPriority	(	int &	sched_type,
		int &	priority
	)

Check if the scheduler type and priority match and adapt to a valid value.

If sched_type is unknown a default is choosen. If priority is invalid within sched_type, a default is choosen.

Returns:: true if the arguments made sense, false if a correction was applied.

Definition at line 51 of file threads.cpp.

References rtos_task_check_priority().

Referenced by RTT::extras::TimerThread::Instance().

bool RTT_API RTT::os::CheckScheduler ( int & sched_type )

Check if the scheduler is a valid type in the current process and adapt to a valid value.

Returns:: true if sched_type made sense, false if a correction was applied.

Definition at line 46 of file threads.cpp.

References rtos_task_check_scheduler().

Referenced by RTT::os::Thread::setScheduler().

INTERNAL_QUAL int RTT::os::rtos_task_check_priority	(	int *	sched_type,
		int *	priority
	)

This function checks (and corrects) a given priority within a given scheduler type.

Incorrect arguments are re-set to a sensible default.

Parameters:

sched_type	An integer denoting a scheduler type, which will be updated if it's not a valid value.
priority	An integer denoting the priority, which will be updated if it's not a valid value (within that scheduler).

Returns:: 0 when it is valid, -1 when invalid and corrected.

Definition at line 244 of file fosi_internal.cpp.

References rtos_task_check_scheduler().

Referenced by CheckPriority(), rtos_task_set_priority(), and rtos_task_set_scheduler().

INTERNAL_QUAL int RTT::os::rtos_task_check_scheduler ( int * sched_type )

This function checks (and corrects) if the given sched_type is valid for this RTOS.

If it's not, a sensible default is returned in the argument

Parameters:

sched_type An integer denoting a scheduler type, which will be updated if it's not a valid value.

Returns:: 0 when it is valid, -1 when invalid and corrected.

Definition at line 283 of file fosi_internal.cpp.

Referenced by CheckScheduler(), rtos_task_check_priority(), rtos_task_make_periodic(), and rtos_task_set_scheduler().

INTERNAL_QUAL int RTT::os::rtos_task_create	(	RTOS_TASK *	task,
		int	priority,
		unsigned	cpu_affinity,
		const char *	name,
		int	sched_type,
		size_t	stack_size,
		void ()(void *)	start_routine,
		ThreadInterface *	obj
	)

Create a thread.

Spawn a new thread with the given arguments. When rtos_task_create returns successfully, the task structure must be initialised fully and be valid.

Parameters:

task	An uninitialised, by the user allocated struct which will be used to store the task data in.
priority	The priority of the thread, to be interpreted by the underlying RTOS.
cpu_affinity	The cpu affinity of the thread (

See also:: rtos_task_set_cpu_affinity).

Parameters:

name	The name for the thread, or null if none is given.
sched_type	The scheduler type, one of ORO_SCHED_OTHER, ORO_SCHED_RT or a value defined by your RTOS.
stack_size	The stack size of this thread, or zero when the default stack size may be used.
start_routine	The entry function that the thread will execute.
obj	The argument to pass to that thread.

Returns:: zero on success, -1 if it could not be created.

Definition at line 57 of file fosi_internal.cpp.

INTERNAL_QUAL int RTT::os::rtos_task_create_main ( RTOS_TASK * main_task )

Initialise the main thread.

Anything necessary to setup the real-time environment on the current RTOS may be done here. This is the first function that the RTT will call in the FOSI layer, when the MainThread object is constructed. Typically, the main thread is assigned a priority, put in a scheduler and memory is locked into RAM.

Definition at line 43 of file fosi_internal.cpp.

INTERNAL_QUAL void RTT::os::rtos_task_delete ( RTOS_TASK * mytask )

This function must join the thread created with rtos_task_create and then clean up the RTOS_TASK struct.

This function may not be called from the thread itself.

Parameters:

mytask The thread to join and cleanup.

Definition at line 277 of file fosi_internal.cpp.

Referenced by rtos_task_make_periodic(), and RTT::os::Thread::terminate().

INTERNAL_QUAL int RTT::os::rtos_task_delete_main ( RTOS_TASK * main_task )

Cleanup the main thread.

This undoes the actions taken by rtos_task_create_main(). This is the last function that the RTT will call in the FOSI layer, when the MainThread object is destructed.

Definition at line 50 of file fosi_internal.cpp.

INTERNAL_QUAL unsigned RTT::os::rtos_task_get_cpu_affinity ( const RTOS_TASK * task )

Return the cpu affinity of a thread.

Parameters:

task	The thread to get the cpu affinity

Returns:: the cpu affinity (

See also:: rtos_task_set_cpu_affinity)

Definition at line 417 of file fosi_internal.cpp.

Referenced by RTT::os::Thread::getCpuAffinity(), and rtos_task_make_periodic().

INTERNAL_QUAL const char * RTT::os::rtos_task_get_name ( const RTOS_TASK * task )

Returns the name by which a task is known in the RTOS.

Parameters:

task	The task to query.

Returns:: It's name.

Definition at line 432 of file fosi_internal.cpp.

Referenced by RTT::os::Thread::getName(), rtos_task_make_periodic(), RTT::os::Thread::setScheduler(), and thread_function().

INTERNAL_QUAL unsigned int RTT::os::rtos_task_get_pid ( const RTOS_TASK * task )

Returns the process ID the OS gave to the task task.

Parameters:

task	The task handle of the thread to query

Returns:: 0 typically denotes the PID could not be obtained, but any interpretation is left to the user of the Operating System.

Definition at line 183 of file fosi_internal.cpp.

Referenced by RTT::os::MainThread::getPid(), RTT::os::Thread::getPid(), and rtos_task_make_periodic().

INTERNAL_QUAL int RTT::os::rtos_task_get_priority ( const RTOS_TASK * task )

Return the priority of a thread.

Parameters:

task	The thread to get the priority of

Returns:: the priority, as recorded by the underlying RTOS.

Definition at line 388 of file fosi_internal.cpp.

Referenced by RTT::os::MainThread::getPriority(), RTT::os::Thread::getPriority(), and rtos_task_make_periodic().

INTERNAL_QUAL int RTT::os::rtos_task_get_scheduler ( const RTOS_TASK * t )

Returns the current scheduler set for task t.

Parameters:

t	The RTOS task to query.

Returns:: The scheduler type defined by your RTOS in which t is running.

Definition at line 214 of file fosi_internal.cpp.

Referenced by RTT::os::MainThread::getScheduler(), RTT::os::Thread::getScheduler(), and rtos_task_make_periodic().

INTERNAL_QUAL int RTT::os::rtos_task_is_self ( const RTOS_TASK * task )

Returns 1 when task is the task struct of the thread calling this function, 0 otherwise.

Parameters:

task	the task struct to compare against.

Return values:

-1	if task is not a valid task struct or this thread is not known to the rtos layer.

Definition at line 190 of file fosi_internal.cpp.

INTERNAL_QUAL void RTT::os::rtos_task_make_periodic	(	RTOS_TASK *	mytask,
		NANO_TIME	nanosecs
	)

This function is to inform the RTOS that a thread is switching between periodic or non-periodic execution.

This may temporarily suspend the thread. For on-line periodic changes, use rtos_task_set_period, which is guaranteed to keep the thread running.

Parameters:

mytask	The RTOS task to change.
nanosecs	Set to zero if you wish to switch to non periodic execution, set to a positive value (the period in nano seconds) if you wish to switch to periodic execution.

Definition at line 105 of file fosi_internal.cpp.

References rtos_task_check_scheduler(), rtos_task_delete(), rtos_task_get_cpu_affinity(), rtos_task_get_name(), rtos_task_get_pid(), rtos_task_get_priority(), rtos_task_get_scheduler(), rtos_task_set_cpu_affinity(), rtos_task_set_period(), rtos_task_set_priority(), rtos_task_set_scheduler(), rtos_task_set_wait_period_policy(), and rtos_task_wait_period().

Referenced by rtos_task_set_period(), RTT::os::Thread::setPeriod(), RTT::os::Thread::start(), and RTT::os::Thread::stop().

INTERNAL_QUAL int RTT::os::rtos_task_set_cpu_affinity	(	RTOS_TASK *	task,
		unsigned	cpu_affinity
	)

Set the cpu affinity of a thread.

Parameters:

task	The thread to change the cpu affinity of
cpu_affinity	is a bit mask with the cpu this thread should be bound. The bit 0 is the cpu 0, the bit 1, the cpu 1 and so on. For example ((1 << 0) \| (1 << 1)) will bound to cpu 0 and 1.

Returns:: 0 if the cpu affinity could be set.

Definition at line 401 of file fosi_internal.cpp.

Referenced by rtos_task_make_periodic(), and RTT::os::Thread::setCpuAffinity().

INTERNAL_QUAL void RTT::os::rtos_task_set_period	(	RTOS_TASK *	mytask,
		NANO_TIME	nanosecs
	)

Change the period of a periodic RTOS task.

You must first use rtos_task_make_periodic() before calling this function. This function may not suspend the thread.

Parameters:

mytask	The RTOS task to change the period.
nanosecs	the new period. As a special exception, if this is equal to zero, it is to inform the RTOS that we'll block this periodic thread for an unspecified amount of time and that this should not trigger a watchdog, or lead to 'catching up' or signalling overruns.

Definition at line 231 of file fosi_internal.cpp.

References rtos_task_make_periodic().

Referenced by rtos_task_make_periodic(), and thread_function().

INTERNAL_QUAL int RTT::os::rtos_task_set_priority	(	RTOS_TASK *	task,
		int	priority
	)

Set the priority of a thread.

Parameters:

task	The thread to change the priority of
priority	The priority as interpreted by the underlying RTOS.

Returns:: 0 if the priority could be set.

Definition at line 372 of file fosi_internal.cpp.

References rtos_task_check_priority().

Referenced by rtos_task_make_periodic(), RTT::os::MainThread::setPriority(), and RTT::os::Thread::setPriority().

INTERNAL_QUAL int RTT::os::rtos_task_set_scheduler	(	RTOS_TASK *	t,
		int	sched_type
	)

Set the scheduler of a given task t to a the type sched_type.

In some RTOS's the scheduler can't be changed or the change can only be done for the calling thread.

Parameters:

t	The RTOS task to change.
sched_type	A scheduler typed known by your RTOS.

Return values:

0	when the scheduler of t was changed successfully
-1	if scheduler for t could not be changed or sched_type is invalid
-2	if sched_type is valid but can only be changed for the current thread which is not t. In this case, the calling code should find a way to let the thread associated with t make the call to rtos_task_set_scheduler().

Definition at line 197 of file fosi_internal.cpp.

References rtos_task_check_priority(), and rtos_task_check_scheduler().

Referenced by rtos_task_make_periodic(), RTT::os::MainThread::setScheduler(), RTT::os::Thread::setScheduler(), and thread_function().

INTERNAL_QUAL void RTT::os::rtos_task_set_wait_period_policy	(	RTOS_TASK *	task,
		int	policy
	)

Set the wait policy of a thread.

Parameters:

task	The RTOS task to change.
policy	The wait policy.

Definition at line 236 of file fosi_internal.cpp.

Referenced by rtos_task_make_periodic(), RTT::os::MainThread::setWaitPeriodPolicy(), and RTT::os::Thread::setWaitPeriodPolicy().

INTERNAL_QUAL int RTT::os::rtos_task_wait_period ( RTOS_TASK * task )

This function is called by a periodic thread which wants to go to sleep and wake up the next period.

Parameters:

task	This must be RTOS_TASK struct of the calling thread.

Returns:: zero on success (or if the thread is non periodic), non-zero to indicate an overrun.

Definition at line 241 of file fosi_internal.cpp.

Referenced by rtos_task_make_periodic(), and thread_function().

INTERNAL_QUAL void RTT::os::rtos_task_yield ( RTOS_TASK * task )

Yields the current thread.

This function may be left empty.

Parameters:

task	The task handle of the current thread.

Definition at line 95 of file fosi_internal.cpp.

Referenced by RTT::os::MainThread::yield(), and RTT::os::Thread::yield().

void* RTT::os::thread_function ( void * t )

This is one time initialisation

The real task starts here.

Definition at line 75 of file Thread.cpp.

References RTT::os::Thread::getName(), RTT::os::Thread::getTask(), RTT::os::Thread::loop(), rtos_task_get_name(), rtos_task_set_period(), rtos_task_set_scheduler(), rtos_task_wait_period(), RTT::os::Thread::step(), and RTT::os::ThreadInterface::threadNumber().

Variable Documentation

AtomicInt RTT_API RTT::os::threads

The number of threads in addition to the main() thread.

The main thread is thread zero (0). threads is increased by one for each PeriodicThread or SingleThread object created and is never decreased.

Definition at line 54 of file threads.hpp.

Referenced by RTT::internal::ListLockFree< connection_t >::ListLockFree().

Classes

Functions

Variables

Detailed Description

Function Documentation

Variable Documentation