#include "priority_schedule_structures.h"
#include "libnotify/notify.h"
#include "libhw/hardware.h"

Include dependency graph for schedule.h:

This graph shows which files directly or indirectly include this file:

Macros
#define	SCHEDULER_DEFAULT_MAX_THREADS 5

#define	SYSTICKS_PER_HZ 80000000

#define	MAX_SYSTICKS_PER_HZ 16777216

#define	SYSCTLCLOCK 16000000

#define	SCHEDULER_MAX_THREADS SCHEDULER_DEFAULT_MAX_THREADS

Typedefs
typedef void(*	pisr_t) (notification note)

Functions
void	schedule_init ()

void	schedule (task_t, frequency_t, DEADLINE_TYPE)

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

sched_task_pool *	schedule_hash_find_int (sched_task_pool *queues, frequency_t target_frequency)

void	schedule_hash_add_int (sched_task_pool queues, sched_task_pool add)

sched_task *	edf_get_edf_queue ()

void	_os_choose_next_thread ()

Variables
static sched_task_pool	SCHEDULER_TASK_QUEUES [5]

static volatile sched_task_pool *	SCHEDULER_UNUSED_QUEUES = NULL

static volatile sched_task_pool *	SCHEDULER_QUEUES = NULL

static sched_task	SCHEDULER_TASKS [5]

static sched_task *	SCHEDULER_UNUSED_TASKS = NULL

Macro Definition Documentation

#define MAX_SYSTICKS_PER_HZ 16777216

Definition at line 21 of file schedule.h.

Referenced by schedule().

#define SCHEDULER_DEFAULT_MAX_THREADS 5

Definition at line 19 of file schedule.h.

#define SCHEDULER_MAX_THREADS SCHEDULER_DEFAULT_MAX_THREADS

Definition at line 25 of file schedule.h.

#define SYSCTLCLOCK 16000000

Definition at line 22 of file schedule.h.

#define SYSTICKS_PER_HZ 80000000

Definition at line 20 of file schedule.h.

Referenced by edf_pop().

Typedef Documentation

typedef void(* pisr_t) (notification note)

Definition at line 28 of file schedule.h.

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 schedule	(	task_t	,
		frequency_t	,
		DEADLINE_TYPE
	)

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:

void schedule_hash_add_int	(	sched_task_pool *	queues,
		sched_task_pool *	add
	)

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]);
     }
 }