int main(void)
{
unsigned long hrttsk_name = nam2num("HRTTSK");
struct sched_param mysched;
mysched.sched_priority = sched_get_priority_max(SCHED_FIFO);
if( sched_setscheduler( 0, SCHED_FIFO, &mysched ) == -1 ) {
puts("ERROR IN SETTING THE SCHEDULER");
perror("errno");
exit(0);
}
if (!(hrttsk = rt_task_init(hrttsk_name, 1, 0, 0))) {
printf("CANNOT INIT TESTB MASTER TASK\n");
exit(1);
}
rt_set_usp_flags_mask(FORCE_SOFT);
rt_task_suspend(hrttsk);
printf("BACKGROUND REAL TIME TASK IS HARD .....\n");
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_make_hard_real_time();
while(rt_is_hard_real_time(hrttsk)) {
rt_task_wait_period();
}
printf("..... BACKGROUND REAL TIME TASK IS SOFT NOW, YOU CAN KILL IT BY HAND\n");
rt_task_delete(hrttsk);
while(1) { sleep(3); printf("BACKGROUND PROCESS STILL RUNNING\n"); }
}
void *ThreadImplLxrt35::runThread(void *arg)
{
ThreadImplLxrt35 *self = static_cast<ThreadImplLxrt35*>(arg);
if (self->m_rt_start_sync == NULL)
{
// Technically, this can never happen because this condition is
// already checked in the Start() function. But who knows!
PRINTF("ERROR: NULL thread start barrier!\n");
}
else
{
self->m_rt_task = rt_task_init(getpid() + pthread_self_rt(), abs(self->m_priority),
DEFAULT_STACK_SIZE, 0);
if (self->m_rt_task == NULL)
{
PRINTF("ERROR: Cannot initialize LXRT task %lu!\n", self->m_thread_id);
PRINTF(" Probably another thread with the same name already exists.\n");
// Let the thread, which started us, continue!
pthread_barrier_wait_rt(self->m_rt_start_sync);
}
else
{
if (self->m_priority < 0)
{
rt_make_hard_real_time();
if (!rt_is_hard_real_time(rt_buddy()))
{
PRINTF("ERROR: Setting thread %lu to hard real-time failed!\n", self->m_thread_id);
}
else
{
// Everything worked as expected, so no message here.
}
}
else
{
// This is a soft realtime thread, so nothing additional has
// to be done here.
}
pthread_barrier_wait_rt(self->m_rt_start_sync);
self->m_thread->runThread();
// Remark: It does not hurt to call this in a soft realtime
// thread, so just skip the hard realtime test.
rt_make_soft_real_time();
}
}
return NULL;
}
static inline void send_to_mbx(FILE *fs, struct LOGMSG msg)
{
RT_TASK *buddy;
msg.msg[MAX_MSG_SIZE - 1] = 0;
if (++msg.nch >= (MAX_MSG_SIZE - 1)) {
msg.nch = MAX_MSG_SIZE - 1;
}
if (!(buddy = rt_buddy()) || (buddy && !rt_is_hard_real_time(buddy))) {
fprintf(stderr, msg.msg);
} else {
msg.fs = fs;
rt_mbx_send_if(logmbx, &msg, sizeof(int) + sizeof(FILE *) + msg.nch);
}
}
void *ThreadImplLxrt33::runThread(void *arg)
{
ThreadImplLxrt33 *self = static_cast<ThreadImplLxrt33*>(arg);
self->m_rt_task = rt_task_init(getpid() + pthread_self_rt(), abs(self->m_priority),
DEFAULT_STACK_SIZE, 0);
if (self->m_rt_task == NULL)
{
PRINTF("ERROR: Cannot initialize LXRT task %lu!\n", self->m_thread_id);
PRINTF(" Probably another thread with the same name already exists.\n");
}
else
{
rt_task_use_fpu(self->m_rt_task, 1);
if (self->m_priority < 0)
{
rt_make_hard_real_time();
if (!rt_is_hard_real_time(rt_buddy()))
{
PRINTF("ERROR: Setting thread %lu to hard real-time failed!\n", self->m_thread_id);
}
else
{
// Everything worked as expected, so no message here.
}
}
else
{
// This is a soft realtime thread, so nothing additional has to
// be done here.
}
self->m_thread->runThread();
rt_make_soft_real_time();
// TODO: Check if this is correct. The RTAI 3.5 and 3.8
// implementations leave this to a call to join().
rt_task_delete(self->m_rt_task);
self->m_rt_task = NULL;
}
return NULL;
}
INTERNAL_QUAL int rtos_task_get_scheduler(const RTOS_TASK* t) {
if ( rt_is_hard_real_time( t->rtaitask ) )
return SCHED_LXRT_HARD;
return SCHED_LXRT_SOFT;
}
