#include "os.h"
#include "inc/hw_nvic.h"
#include "inc/hw_types.h"
#include "libstd/nexus.h"
#include "libut/utlist.h"
#include "libsystick/systick.h"
#include "libschedule/schedule.h"

Include dependency graph for os.c:

Functions
void	os_threading_init ()

int8_t	get_os_num_threads ()

tcb_t *	os_add_thread (task_t task)

tcb_t *	os_remove_thread (task_t task)

int32_t	os_running_thread_id ()

tcb_t *	os_tcb_of (const task_t task)

void	os_launch ()

always void	_os_reset_thread_stack (tcb_t *tcb, task_t task)

always void	scheduler_reschedule (void)

void	SysTick_Handler ()

void	PendSV_Handler ()

void	os_suspend ()

void	schedule (task_t task, frequency_t frequency, DEADLINE_TYPE seriousness)

void	schedule_aperiodic (pisr_t pisr, HW_TYPE hw_type, hw_metadata metadata, microseconds_t allowed_run_time, DEADLINE_TYPE seriousness)

void	schedule_init ()

sched_task_pool *	schedule_hash_find_int (sched_task_pool *queues, frequency_t target_frequency)

void	edf_init ()

void	edf_insert (sched_task *task)

tcb_t *	edf_pop ()

sched_task *	edf_get_edf_queue ()

void	_os_choose_next_thread ()

Variables
static int32_t	OS_PROGRAM_STACKS [SCHEDULER_MAX_THREADS][100]

volatile sched_task *	executing

volatile sched_task_pool *	pool

volatile uint32_t	clock = 0

volatile sched_task	EDF [SCHEDULER_MAX_THREADS]

volatile sched_task *	EDF_QUEUE = NULL

bool	OS_FIRST_RUN = true

bool	OS_THREADING_INITIALIZED

uint8_t	OS_NUM_THREADS

Function Documentation

void _os_choose_next_thread ( )

Precondition: disable interrupts before we get here

Definition at line 544 of file os.c.

References scheduler_reschedule().

Referenced by os_launch().

                               {
 
     scheduler_reschedule();
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

sched_task* edf_get_edf_queue ( )

Definition at line 538 of file os.c.

References EDF_QUEUE.

                                 {
     return EDF_QUEUE;
 }

void edf_init ( )

Precondition: ensure at least one task has been scheduled prior to invoking this function

Definition at line 475 of file os.c.

References DL_EDF_INSERT, edf_insert(), sched_task_pool::next, sched_task_pool::queue, and SCHEDULER_QUEUES.

Referenced by os_launch().

                 {
 
     sched_task_pool *start = SCHEDULER_QUEUES;
     sched_task_pool *next = start->next;
 
     /* avoid the NULL EDF_QUEUE to allow optimized form of `edf_insert' */
     DL_EDF_INSERT(EDF_QUEUE, start->queue);
 
     /* Create the rest of the EDF */
     while(next && next != start) {
         /* DL_EDF_INSERT(EDF_QUEUE, next->queue); */
         edf_insert(next->queue);
         next = next->next;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void edf_insert ( sched_task * )

Add by insertion sort the specified task into the EDF queue

Definition at line 491 of file os.c.

References sched_task::absolute_deadline, DL_EDF_INSERT, DL_EDF_PREPEND, EDF_QUEUE, and sched_task::pri_next.

Referenced by edf_init(), edf_pop(), and scheduler_reschedule().

                                   {
 
     sched_task *elt = EDF_QUEUE;
 
     while(elt && task->absolute_deadline > elt->absolute_deadline) {
         elt = elt->pri_next;
     }
     /* inject task at point -- if elt is null, this is the new end*/
     if (elt) {
         if (elt == EDF_QUEUE) {
             DL_EDF_PREPEND(elt, task);
             EDF_QUEUE = elt;
         } else {
             DL_EDF_PREPEND(elt, task);
         }
     } else {
         /* TODO: this incurs the O(n) again, optimize */
         DL_EDF_INSERT(EDF_QUEUE, task);
     }
 }

Here is the caller graph for this function:

tcb_t* edf_pop ( )

Definition at line 512 of file os.c.

References sched_task::absolute_deadline, sched_task_pool::deadline, edf_insert(), EDF_QUEUE, sched_task::next, sched_task_pool::next, sched_task::pri_next, sched_task_pool::queue, SCHEDULER_QUEUES, SYSTICKS_PER_HZ, and sched_task::tcb.

                  {
 
     volatile sched_task *executing = EDF_QUEUE;
     volatile sched_task_pool *pool = SCHEDULER_QUEUES;
 
     /* DL_EDF_DELETE(EDF_QUEUE, elt); */
     /* TODO: CHECKME: should we use pri_next or pri_prev?? */
     EDF_QUEUE = EDF_QUEUE->pri_next;
 
     /* KLUDGE: fix this for production */
     while (pool->queue != executing) {
         pool = pool->next;
     }
     /* will drop out with pool->queue = executing */
 
     executing->absolute_deadline = pool->deadline * SYSTICKS_PER_HZ;
 
     /* do the recycling, change the pool's head */
     /* TODO: CHECKME: should we use next or prev?? */
     pool->queue = executing->next;
     edf_insert(pool->queue);
 
     /* TODO: after use, put the command back in the appropriate pool */
     return executing->tcb;
 }

Here is the call graph for this function:

void PendSV_Handler ( void )

Definition at line 291 of file os.c.

References HWREG, NVIC_ST_CURRENT, and os_running_threads.

Referenced by __attribute__().

                       {
 
     asm volatile("CPSID  I");
 
     /* -------------------------------------------------- */
     /* phase 1: store context                             */
     /* -------------------------------------------------- */
 
     /* load the msp of thread A into r12 */
     asm volatile("mrs     r12, msp" );
 
     /* save thread A's registers into the msp */
     asm volatile("stmdb   r12!, {r4 - r11, lr}");
 
     /* -------------------------------------------------- */
     /* phase 2: os_running_threads manipulation    */
     /* -------------------------------------------------- */
 
     /* set the profiling data structures for the current thread */
     /* should this be "enabled" or "disabled"? */
     #ifdef OS_TIME_PROFILING_ENABLED
     if (os_running_threads->time_started >= 0) {
         os_running_threads->time_running_last =
             HWREG(NVIC_ST_CURRENT) - os_running_threads->time_started;
 
         /* If we haven't reached the max samples yet, increment the
            number of samples taken */
         if (os_running_threads->time_running_samples_taken < OS_TIME_MAX_SAMPLES) {
             ++(os_running_threads->time_running_samples_taken);
         }
 
         HWREG(NVIC_ST_CURRENT) = 0;
         /* _os_reset_thread_stack(os_running_threads, os_running_threads->entry_point); */
 
         /* take another sample */
         os_running_threads->time_running_avg = os_running_threads->time_running_samples_taken > 1 ?
             /* if true */
             (os_running_threads->time_running_last +
              os_running_threads->time_running_samples_taken * os_running_threads->time_running_avg) /
             (os_running_threads->time_running_samples_taken+1) :
             /* else */
             os_running_threads->time_running_last;
 
     }
     #endif /* OS_TIME_PROFILING */
 
     /* load the value of os_running_threads */
     asm volatile("LDR     R2, =os_running_threads");
 
     /* r3 = *os_running_threads, of thread A */
     asm volatile("LDR     R3, [R2]");
 
     /* load the value of os_running_threads->next into r1 */
     asm volatile("LDR     R1, =OS_NEXT_THREAD");
     asm volatile("LDR     R1, [R1]");
 
     /* os_running_threads = OS_NEXT_THREAD */
     asm volatile("STR     R1, [R2]");
 
     /* -------------------------------------------------- */
     /* phase 3: load context                              */
     /* -------------------------------------------------- */
 
     /* store the msp from thread A */
     asm volatile("str     r12, [r3, #0]");
 
     /* load thread B's msp */
     asm volatile("ldr     r12, [r1]");
 
     /* set the profiling data structures for the next thread */
     #ifdef OS_TIME_PROFILING_ENABLED
         os_running_threads->time_started = HWREG(NVIC_ST_CURRENT);
     #endif  /* OS_TIME_PROFILING_ENABLED */
 
     /* load thread B's context */
     asm volatile("ldmia   r12!, {r4 - r11, lr}");
 
     /* put thread B's msp into the arch msp register */
     asm volatile("msr     msp, r12");
 
     /* reenable interrupts */
     asm volatile("CPSIE   I");
 
     asm volatile ("bx lr");
 }

Here is the caller graph for this function:

void schedule	(	task_t	task,
		frequency_t	frequency,
		DEADLINE_TYPE	seriousness
	)

Definition at line 386 of file os.c.

References sched_task::absolute_deadline, CDL_APPEND, CDL_DELETE, CDL_PREPEND, clock, sched_task_pool::deadline, MAX_SYSTICKS_PER_HZ, sched_task_pool::next, NULL, os_add_thread(), postpone_death, sched_task_pool::prev, sched_task_pool::queue, schedule_hash_find_int(), SCHEDULER_QUEUES, SCHEDULER_UNUSED_QUEUES, SCHEDULER_UNUSED_TASKS, sched_task::seriousness, sched_task::task, and sched_task::tcb.

Referenced by main().

                                                                              {
 
     sched_task *ready_task = NULL;
     sched_task_pool *ready_queue = NULL;
 
     /* Grab a new task from the unused task pile */
     ready_task = SCHEDULER_UNUSED_TASKS;
     CDL_DELETE(SCHEDULER_UNUSED_TASKS, ready_task);
 
     /* Set new task's metadata */
     ready_task->task = task;
     ready_task->seriousness = seriousness;
 
     if (frequency > MAX_SYSTICKS_PER_HZ) {
         postpone_death();
     }
     ready_task->absolute_deadline = frequency + clock;
 
     ready_task->tcb = os_add_thread(task);
 
     /* Test the pool of ready queues for a queue of tasks with this
      * frequency */
     /* todo: uthash configurable without malloc */
     ready_queue = schedule_hash_find_int(SCHEDULER_QUEUES, frequency);
     /* HASH_FIND_INT(SCHEDULER_QUEUES, &frequency, ready_queue); */
 
     /* No similar tasks exist yet -- create the pool */
     if (!ready_queue) {
         /* Grab a new queue, remove it from the unused pile,
          * initialize it and associate it with this requency of
          * task */
         ready_queue = SCHEDULER_UNUSED_QUEUES;
         CDL_DELETE(SCHEDULER_UNUSED_QUEUES, ready_queue);
 
         ready_queue->deadline = frequency;
         if (!SCHEDULER_QUEUES) {
             SCHEDULER_QUEUES = ready_queue;
             SCHEDULER_QUEUES->next = SCHEDULER_QUEUES;
             SCHEDULER_QUEUES->prev = SCHEDULER_QUEUES;
         } else {
             CDL_PREPEND(SCHEDULER_QUEUES, ready_queue);
         }
         /* HASH_ADD_INT(SCHEDULER_QUEUES, deadline, ready_queue); */
     }
 
     /* Add task to ready queue */
     CDL_APPEND(ready_queue->queue, ready_task);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void schedule_aperiodic	(	pisr_t	,
		HW_TYPE	,
		hw_metadata	,
		microseconds_t	,
		DEADLINE_TYPE
	)

Schedule a pseudo-isr to be executed when a hardware event described by HW_TYPE and hw_metadata occurs.

Definition at line 435 of file os.c.

References _hw_subscribe().

                                                    {
 
     /* todo: utilize \allowed_run_time, \seriousness */
     _hw_subscribe(hw_type, metadata, pisr, true);
 }

Here is the call graph for this function:

sched_task_pool* schedule_hash_find_int	(	sched_task_pool *	queues,
		frequency_t	target_frequency
	)

Definition at line 456 of file os.c.

References sched_task_pool::deadline, sched_task_pool::next, and NULL.

Referenced by schedule().

                                                                                                {
 
     sched_task_pool* start = queues;
     sched_task_pool* inspect = queues;
 
     if (!inspect) { return NULL; }
 
     do {
         if(inspect->deadline == target_frequency) {
             return inspect;
         }
         inspect = inspect->next;
     } while (inspect != start);
     return NULL;
 }

Here is the caller graph for this function:

void schedule_init ( )

Initialize all deep datastructures used by libschedule.

Definition at line 445 of file os.c.

References DL_PREPEND, SCHEDULER_MAX_THREADS, SCHEDULER_TASK_QUEUES, SCHEDULER_TASKS, SCHEDULER_UNUSED_QUEUES, and SCHEDULER_UNUSED_TASKS.

Referenced by os_threading_init().

                      {
 
     int32_t i;
     for(i=0; i<SCHEDULER_MAX_THREADS; ++i) {
         /* Add all tasks to the unused pile */
         DL_PREPEND(SCHEDULER_UNUSED_TASKS, &SCHEDULER_TASKS[i]);
         /* Add all task queues to the unused pile */
         DL_PREPEND(SCHEDULER_UNUSED_QUEUES, &SCHEDULER_TASK_QUEUES[i]);
     }
 }

Here is the caller graph for this function:

always void scheduler_reschedule ( void )

inline

Definition at line 237 of file os.c.

References sched_task::absolute_deadline, clock, sched_task_pool::deadline, edf_insert(), EDF_QUEUE, FAULT_PENDSV, HWREG, IntPendSet(), sched_task::next, sched_task_pool::next, NVIC_ST_CURRENT, OS_FIRST_RUN, OS_NEXT_THREAD, sched_task::pri_next, sched_task_pool::queue, SCHEDULER_QUEUES, SysCtlClockGet(), SysTickDisable(), SysTickEnable(), SysTickIntEnable(), SysTickPeriodSet(), and sched_task::tcb.

Referenced by _os_choose_next_thread(), os_suspend(), and SysTick_Handler().

                                 {
     executing = EDF_QUEUE;
     pool = SCHEDULER_QUEUES;
 
     /* find the queue that the executing task is a member of */
     /* TODO: Should we link from the sched_task to the
        sched_task_pool? That will avoid this loop. */
     while (pool->queue != executing) {
         pool = pool->next;
     }
 
     /* update  */
     if (EDF_QUEUE) {
         EDF_QUEUE = EDF_QUEUE->pri_next;
     }
 
     if (OS_FIRST_RUN) {
         OS_FIRST_RUN = false;
         SysTickEnable();
         SysTickIntEnable();
     } else {
         clock += pool->deadline;
     }
 
     SysTickDisable();
     /* SysTickPeriodSet(SysCtlClockGet() / (executing->absolute_deadline - clock)); */
     SysTickPeriodSet(SysCtlClockGet() / (pool->deadline));
     HWREG(NVIC_ST_CURRENT) = 0;
     executing->absolute_deadline = pool->deadline + clock;
     SysTickEnable();
 
     /* do the recycling, change the pool's head */
     pool->queue = executing->next;
     edf_insert(pool->queue);
 
     OS_NEXT_THREAD = executing->tcb;
 
     /* Queue the PendSV_Handler after this ISR returns */
     IntPendSet(FAULT_PENDSV);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SysTick_Handler ( void )

Warning: Ensure you have something to run before enabling SysTick

Definition at line 282 of file os.c.

References scheduler_reschedule().

Referenced by __attribute__().

                        {
 
     asm volatile("CPSID  I");
 
     scheduler_reschedule();
 
     asm volatile("CPSIE  I");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

volatile uint32_t clock = 0

Definition at line 20 of file os.c.

Referenced by schedule(), and scheduler_reschedule().

volatile sched_task EDF[SCHEDULER_MAX_THREADS]

Statically allocated array of periodic tasks arranged by increasing time-to-deadline.

Definition at line 24 of file os.c.

volatile sched_task* EDF_QUEUE = NULL

Linked list of tasks (with different periods) ready to be run.

Definition at line 27 of file os.c.

Referenced by edf_get_edf_queue(), edf_insert(), edf_pop(), and scheduler_reschedule().

volatile sched_task* executing

Definition at line 17 of file os.c.

bool OS_FIRST_RUN = true

Definition at line 29 of file os.c.

Referenced by scheduler_reschedule().

uint8_t OS_NUM_THREADS

Definition at line 32 of file os.c.

Referenced by get_os_num_threads(), and os_remove_thread().

int32_t OS_PROGRAM_STACKS[SCHEDULER_MAX_THREADS][100]

static

A block of memory for each thread's local stack.

Definition at line 16 of file os.c.

Referenced by _os_reset_thread_stack(), and os_threading_init().

bool OS_THREADING_INITIALIZED

Definition at line 31 of file os.c.

Referenced by os_threading_init().

volatile sched_task_pool* pool

Definition at line 18 of file os.c.

Functions

Variables

Function Documentation

Variable Documentation