Operating system routines. More...

Data Structures
struct	hwcontext

struct	swcontext

Macros
#define	PIDWORK_BUFFER_SIZE 32

#define	OS_STACK_SIZE 100

#define	OS_NUM_POOLS 2

#define	OS_SYSTEM_POOL 0

#define	OS_REAL_TIME_POOL 0

#define	OS_INTERACTIVE_POOL 1

#define	os_spawn_thread(_thread, _priority) os_add_thread(_thread, priority)

#define	os_kill_thread(_thread) os_remove_thread(_thread)

#define	os_surrender_context() os_suspend()

Typedefs
typedef struct hwcontext	hwcontext_t

typedef struct swcontext	swcontext_t

Functions
void	pidwork_increment ()

void	pidwork_record ()

void	os_threading_init (void)

void	_os_reset_thread_stack (tcb_t *tcb, task_t task)

int8_t	get_os_num_threads ()

tcb_t *	os_add_thread (task_t)

tcb_t *	os_remove_thread (task_t)

tcb_t *	os_tcb_of (task_t)

tcb_t *	_os_next_dead_thread ()

int32_t	os_running_thread_id ()

void	os_launch ()

void	os_suspend ()

Variables
static volatile uint32_t	PIDWORK

static volatile uint32_t	HIGHEST_PIDWORK

static volatile uint32_t	LOWEST_PIDWORK

static volatile uint32_t	PIDWORK_IDX

static volatile uint32_t	PIDWORK_BUFFER [32]

static tcb_t *	os_running_threads = NULL

static tcb_t *	os_dead_threads = NULL

static tcb_t *	OS_NEXT_THREAD

static tcb_t	OS_THREADS [SCHEDULER_MAX_THREADS]

static tcb_t *	OS_THREAD_POOL [2]

Detailed Description

Operating system routines.

''

Author: Hershal Bhave; Eric Crosson

Version: 0.1

Date: 2015

Precondition: None

Copyright: GNU Public License.

Macro Definition Documentation

#define OS_INTERACTIVE_POOL 1

Second highest priority thread pool alias

Definition at line 32 of file os.h.

Referenced by main().

#define os_kill_thread ( _thread ) os_remove_thread(_thread)

An alias to . Feels like home sweet home.

Definition at line 39 of file os.h.

#define OS_NUM_POOLS 2

Static number of thread pools of distinct priority in use

Definition at line 25 of file os.h.

Referenced by os_threading_init().

#define OS_REAL_TIME_POOL 0

Highest priority thread pool alias

Definition at line 30 of file os.h.

#define os_spawn_thread	(	_thread,
		_priority
	)	os_add_thread(_thread, priority)

An alias to . Feels like home sweet home.

Definition at line 35 of file os.h.

#define OS_STACK_SIZE 100

Maximum number of 32-bit values allowed in each thread's stack

Definition at line 22 of file os.h.

Referenced by _os_reset_thread_stack().

#define os_surrender_context ( ) os_suspend()

A convenience alias to to circumnavigate the naming conventions chosen by the couse Administrators.

Definition at line 142 of file os.h.

Referenced by hw_daemon(), led_blink_blue(), led_blink_green(), led_blink_red(), and postpone_suicide().

#define OS_SYSTEM_POOL 0

Highest priority thread pool alias

Definition at line 28 of file os.h.

Referenced by main().

#define PIDWORK_BUFFER_SIZE 32

Definition at line 14 of file jitter.h.

Typedef Documentation

typedef struct hwcontext hwcontext_t

The contents of the stack immediately after a function call.

typedef struct swcontext swcontext_t

The contents of the stack during a context switch.

Function Documentation

tcb_t* _os_next_dead_thread ( )

Returns the next dead thread in the dead thread circle. If the length of the dead thread circle is greater than 1, then the current dead thread is removed and the circle is relinked with the next dead thread. If the circle contains only one dead thread, then that thread is removed and the current dead thread is set to null. If there is no thread in the dead thread circle, then it retuns null.

Returns: The first thread removed from the dead thread circle, or null if the dead thread circle is empty.

void _os_reset_thread_stack	(	tcb_t *	tcb,
		task_t	task
	)

inline

Resets the thread stack for a given tcb to run a given task.

Parameters

thread	the thread whose stack is to be reset
the	task for which the thread should run

Definition at line 197 of file os.c.

References tcb_t::id, swcontext::lr, OS_PROGRAM_STACKS, OS_STACK_SIZE, hwcontext::pc, hwcontext::psr, hwcontext::r0, hwcontext::r1, swcontext::r10, swcontext::r11, hwcontext::r2, hwcontext::r3, swcontext::r4, swcontext::r5, swcontext::r6, swcontext::r7, swcontext::r8, swcontext::r9, and tcb_t::sp.

Referenced by os_add_thread().

                                                      {
 
     hwcontext_t* hwcontext = (hwcontext_t*)
         (((uint32_t)OS_PROGRAM_STACKS[tcb->id]) +
          sizeof(uint32_t)*OS_STACK_SIZE - sizeof(hwcontext_t));
 
     swcontext_t* swcontext = (swcontext_t*)
         (((uint32_t)hwcontext) - sizeof(swcontext_t));
 
     hwcontext->pc = (uint32_t)(task);
     hwcontext->psr = 0x01000000;
 
     swcontext->lr = 0xfffffff9;
 
     #ifdef OS_REGISTER_DEBUGGING_ENABLED
     hwcontext->r0 = 0x00000000;
     hwcontext->r1 = 0x01010101;
     hwcontext->r2 = 0x02020202;
     hwcontext->r3 = 0x03030303;
 
     swcontext->r4 = 0x04040404;
     swcontext->r5 = 0x05050505;
     swcontext->r6 = 0x06060606;
     swcontext->r7 = 0x07070707;
     swcontext->r8 = 0x08080808;
     swcontext->r9 = 0x09090909;
     swcontext->r10 = 0x10101010;
     swcontext->r11 = 0x11111111;
     #endif  /* OS_REGISTER_DEBUGGING_ENABLED */
 
     tcb->sp = (uint32_t*)(((uint32_t)hwcontext) - sizeof(swcontext_t));
     asm volatile ("PUSH {R9, R10, R11, R12}");
     asm volatile ( "mrs     r12, msp" );
     asm volatile ( "mrs     r11, msp" );
     asm volatile ( "mrs     r10, control" );
 
     asm volatile ("POP {R9, R10, R11, R12}");
 }

Here is the caller graph for this function:

int8_t get_os_num_threads ( )

Definition at line 68 of file os.c.

References OS_NUM_THREADS.

                             {
     return OS_NUM_THREADS;
 }

tcb_t* os_add_thread ( task_t )

Adds a new thread with the specified task.

Returns: the TCB of the newly added thread, null if the addition was not possible for some reason.

Definition at line 72 of file os.c.

References _os_reset_thread_stack(), atomic_end, atomic_start, CDL_DELETE, tcb_t::entry_point, and os_dead_threads.

Referenced by hw_init_daemon(), main(), and schedule().

                                   {
 
     int32_t status;
     tcb_t* thread_to_add;
 
     /* 1. Disable interrupts and save the priority mask */
     atomic_start();
 
     /* 2. Pop the task from the dead_thread pile */
     thread_to_add = os_dead_threads;
     CDL_DELETE(os_dead_threads, thread_to_add);
 
     /* 3. Add the thread to the appropriate priority pool. */
     /* CDL_APPEND(os_running_threads, thread_to_add); */
     /* CDL_APPEND(OS_THREAD_POOL[priority], thread_to_add); */
 
     /* 4. Set the initial stack contents for the new thread. */
     _os_reset_thread_stack(thread_to_add, task);
 
     /* 5. Set metadata for this thread's TCB. */
 
     /* TODO: Remove this from semaphore. The scheduler manages
      * this. */
     /* thread_to_add->status = THREAD_RUNNING; */
     thread_to_add->entry_point = task;
     /* thread_to_add->priority = priority; */
     /* thread_to_add->sleep_timer = 0; */
 
     atomic_end();
 
     /* 5. Return. */
     return thread_to_add;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void os_launch ( )

Launches the operating system.

Note: This function drastically changes the execution paradigm of the machine; do not expect to call it and be able to return to the previous context.

Definition at line 161 of file os.c.

References _os_choose_next_thread(), edf_init(), OS_NEXT_THREAD, and os_running_threads.

Referenced by main().

                  {
 
     edf_init();
     _os_choose_next_thread();
     os_running_threads = OS_NEXT_THREAD;
 
     /* acquire the pointer to the stack pointer here */
     asm volatile("LDR     R0, =OS_NEXT_THREAD");
 
     /* acquire the current value of the stack pointer */
     asm volatile("LDR R0, [R0]");
     asm volatile("LDR R0, [R0]");
 
     /* set the process stack value */
     asm volatile("MSR MSP, R0");
 
     /* change EXC_RETURN for return on MSP */
     /* asm volatile("ORR LR, LR, #4"); */
 
     /* change the active stack to use msp */
     /* asm volatile("MRS R0, CONTROL"); */
     /* asm volatile("ORR R0, R0, #2"); */
     /* asm volatile("MSR CONTROL, R0"); */
 
     asm volatile("POP     {R4-R11}");
 
     asm volatile("POP     {LR}");
     asm volatile("POP     {R0-R3}");
 
     asm volatile("pop {r12, lr}");
     asm volatile("pop {pc}");
 
     asm volatile ("BX LR");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

tcb_t* os_remove_thread ( task_t )

Remove a thread from the queue the schedule will choose from.

Parameters

The	task to kill. This should be the task that was used to start the thread to remove via .

Returns: The newly released tcb

Definition at line 106 of file os.c.

References CDL_APPEND, CDL_DELETE, tcb_t::entry_point, tcb_t::next, NULL, os_dead_threads, OS_NUM_THREADS, os_tcb_of(), OS_THREAD_POOL, tcb_t::prev, and tcb_t::priority.

                                      {
 
     int32_t status;
     tcb_t* thread_to_remove;
 
     /* 1. Disable interrupts and save the priority mask */
     /* TODO: clean this up, make uniform */
     status = StartCritical();
 
     /* 2. Pop the task from the running_thread pile and add it to the
      * list of dead threads. */
     thread_to_remove = os_tcb_of(task);
     CDL_DELETE(OS_THREAD_POOL[thread_to_remove->priority], thread_to_remove);
     /* Append means low tcb_t memory reusability. Prepend means high */
     CDL_APPEND(os_dead_threads, thread_to_remove);
 
     /* OPTIONAL TODO: do the check for overwritten stacks as long as
      * we kill every thread in our testing we'll get valuable yet
      * unobtrusive debugging data. also consider a check on the
      * immutable fields, using the offset from the array base as
      * verification. */
 
     /* 3. Reset metadata for this thread's TCB. */
     /* thread_to_remove->status = THREAD_DEAD; */
     thread_to_remove->entry_point = NULL;
     thread_to_remove->next = NULL;
     thread_to_remove->prev = NULL;
 
     /* 4. Return. */
     /* TODO: clean this up, make uniform */
     --OS_NUM_THREADS;
 
     EndCritical(status);
     return thread_to_remove;
 }

Here is the call graph for this function:

int32_t os_running_thread_id ( )

Definition at line 142 of file os.c.

References tcb_t::id, and os_running_threads.

                                {
 
     return os_running_threads->id;
 }

void os_suspend ( )

Put the invoking thread to sleep and let another thread take over. This s another way to say "set the interrupt bit of the \PendSV_Handler".

Definition at line 380 of file os.c.

References scheduler_reschedule().

                   {
 
     scheduler_reschedule();
 }

Here is the call graph for this function:

tcb_t* os_tcb_of ( task_t )

Return the tcb used to control the specified task_t.

Parameters

The	task to lookup the tcb of

Returns: The tcb of the specified task_t

Definition at line 147 of file os.c.

References NULL, OS_THREADS, postpone_death, and SCHEDULER_MAX_THREADS.

Referenced by os_remove_thread().

                                     {
 
     int32_t i;
     for(i=0; i<SCHEDULER_MAX_THREADS; ++i) {
         if (task == OS_THREADS[i].entry_point) {
             return &OS_THREADS[i];
         }
     }
 #ifndef DANGER_ZONE
     postpone_death();
 #endif
     return NULL;
 }

Here is the caller graph for this function:

void os_threading_init ( void )

Initialize the threading engine, setting all threads to dead. This initializes the dead thread circle appropriately and sets the running thread circle to null.

Definition at line 34 of file os.c.

References CDL_APPEND, tcb_t::entry_point, tcb_t::id, NULL, os_dead_threads, OS_NUM_POOLS, OS_PROGRAM_STACKS, os_running_threads, OS_THREAD_POOL, OS_THREADING_INITIALIZED, OS_THREADS, schedule_init(), SCHEDULER_MAX_THREADS, and tcb_t::sp.

Referenced by main().

                          {
 
     uint32_t i;
 
     /* This check exists so libraries may call os_threading_init
      * without breaking everything. We dont' want to contribute to the
      * black magic that is the specific initialization of TI
      * libraries, do we? */
     if (OS_THREADING_INITIALIZED) {
         return;
     }
 
     os_running_threads = NULL;
 
     /* Initialize thread metadata */
     for (i=0; i<SCHEDULER_MAX_THREADS; ++i) {
         CDL_APPEND(os_dead_threads, &OS_THREADS[i]);
         OS_THREADS[i].sp = OS_PROGRAM_STACKS[i];
         OS_THREADS[i].id = i;
         OS_THREADS[i].entry_point = NULL;
         /* OS_THREADS[i].status = THREAD_DEAD; */
         /* OS_THREADS[i].sleep_timer = 0; */
     }
 
     /* Initialize thread pool metadata */
     for (i=0; i<OS_NUM_POOLS; ++i) {
         OS_THREAD_POOL[i] = (tcb_t*) NULL;
     }
 
     OS_THREADING_INITIALIZED = true;
 
     schedule_init();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pidwork_increment ( )

Definition at line 15 of file jitter.c.

References PIDWORK.

                          {
 
     while(1) {
         asm volatile("CPSID  I");
         ++PIDWORK;
         asm volatile("CPSIE  I");
     }
 }

void pidwork_record ( )

A thread that continuously toggles GPIO pin 2 on GPIO_PORT_F.

Definition at line 25 of file jitter.c.

References HIGHEST_PIDWORK, LOWEST_PIDWORK, PIDWORK, PIDWORK_BUFFER, PIDWORK_BUFFER_SIZE, and PIDWORK_IDX.

                       {
 
     while(1) {
         if (PIDWORK != 0) {
             if (HIGHEST_PIDWORK < PIDWORK) {
                 HIGHEST_PIDWORK = PIDWORK;
             }
             if (LOWEST_PIDWORK > PIDWORK) {
                 LOWEST_PIDWORK = PIDWORK;
             }
             PIDWORK_BUFFER[PIDWORK_IDX] = PIDWORK;
             PIDWORK_IDX = (PIDWORK_IDX + 1) & PIDWORK_BUFFER_SIZE;
         }
         PIDWORK = 0;
     }
 }

Variable Documentation

volatile uint32_t HIGHEST_PIDWORK

static

Definition at line 17 of file jitter.h.

Referenced by pidwork_init(), and pidwork_record().

volatile uint32_t LOWEST_PIDWORK

static

Definition at line 18 of file jitter.h.

Referenced by pidwork_init(), and pidwork_record().

tcb_t* os_dead_threads = NULL

static

A circular doubly linked list of currently dead threads.

Definition at line 48 of file os.h.

Referenced by os_add_thread(), os_remove_thread(), and os_threading_init().

tcb_t* OS_NEXT_THREAD

static

Communication mailbox from the SysTick_Handler to the PendSV_Handler; will contain the tcb_t* of the next thread to execute come PendSV_Handler execution time.

Definition at line 78 of file os.h.

Referenced by os_launch(), and scheduler_reschedule().

tcb_t* os_running_threads = NULL

static

A circular doubly linked list of currently running threads.