RIOT-OS/RIOT
RIOT-OS/RIOT
1
0
Fork 0
mirror of https://github.com/RIOT-OS/RIOT.git synced 2024-12-29 04:50:03 +01:00
Code Releases Activity

core: refactor sched_run

Browse Source 
`sched_run()` was cluttered. Many individual changes were done without a
proper refactoring.
This commit is contained in:
René Kijewski 2014-10-18 18:41:40 +02:00
parent 1548f93e76
commit 9ddbf57709
2 changed files with 46 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
core/include/sched.h
View File

@ -100,8 +100,9 @@
/**
* @brief Triggers the scheduler to schedule the next thread
* @returns 1 if sched_active_thread/sched_active_pid was changed, 0 otherwise.
*/
void sched_run(void);
int sched_run(void);
/**
* @brief Set the status of the specified process

92
core/sched.c
View File

@ -53,70 +53,66 @@ static void (*sched_cb) (uint32_t timestamp, uint32_t value) = NULL;
schedstat sched_pidlist[KERNEL_PID_LAST + 1];
#endif
void sched_run(void)
int sched_run(void)
{
sched_context_switch_request = 0;
#ifdef SCHEDSTATISTICS
unsigned long time = hwtimer_now();
#endif
tcb_t *my_active_thread = (tcb_t *)sched_active_thread;
if (my_active_thread) {
if (my_active_thread->status == STATUS_RUNNING) {
my_active_thread->status = STATUS_PENDING;
}
#ifdef SCHED_TEST_STACK
if (*((unsigned int *)my_active_thread->stack_start) != (unsigned int) my_active_thread->stack_start) {
printf("scheduler(): stack overflow detected, task=%s pid=%" PRIkernel_pid "\n", my_active_thread->name, my_active_thread->pid);
}
#endif
#ifdef SCHEDSTATISTICS
if (sched_pidlist[my_active_thread->pid].laststart) {
sched_pidlist[my_active_thread->pid].runtime_ticks += time - sched_pidlist[my_active_thread->pid].laststart;
}
#endif
}
DEBUG("\nscheduler: previous task: %s\n", (my_active_thread == NULL) ? "none" : my_active_thread->name);
tcb_t *active_thread = (tcb_t *)sched_active_thread;
/* The bitmask in runqueue_bitcache is never empty,
* since the threading should not be started before at least the idle thread was started.
*/
int nextrq = bitarithm_lsb(runqueue_bitcache);
my_active_thread = clist_get_container(sched_runqueues[nextrq], tcb_t, rq_entry);
DEBUG("scheduler: first in queue: %s\n", my_active_thread->name);
tcb_t *next_thread = clist_get_container(sched_runqueues[nextrq], tcb_t, rq_entry);
kernel_pid_t my_next_pid = my_active_thread->pid;
DEBUG("scheduler: active thread: %" PRIkernel_pid ", next thread: %" PRIkernel_pid "\n",
(active_thread == NULL) ? KERNEL_PID_UNDEF : active_thread->pid,
next_thread->pid);
if (active_thread == next_thread) {
DEBUG("scheduler: done, sched_active_thread was not changed.\n");
return 0;
}
#ifdef SCHEDSTATISTICS
unsigned long time = hwtimer_now();
#endif
if (active_thread) {
if (active_thread->status == STATUS_RUNNING) {
active_thread->status = STATUS_PENDING;
}
#ifdef SCHED_TEST_STACK
if (*((uintptr_t *) active_thread->stack_start) != (uintptr_t) active_thread->stack_start) {
printf("scheduler(): stack overflow detected, pid=%" PRIkernel_pid "\n", active_thread->pid);
}
#endif
#ifdef SCHEDSTATISTICS
schedstat *active_stat = &sched_pidlist[active_thread->pid];
if (active_stat->laststart) {
active_stat->runtime_ticks += time - active_stat->laststart;
}
#endif
}
#if SCHEDSTATISTICS
sched_pidlist[my_next_pid].laststart = time;
sched_pidlist[my_next_pid].schedules++;
if ((sched_cb) && (my_next_pid != sched_active_pid)) {
sched_cb(time, my_next_pid);
schedstat *next_stat = &sched_pidlist[next_thread->pid];
next_stat->laststart = time;
next_stat->schedules++;
if (sched_cb) {
sched_cb(time, next_thread->pid);
}
#endif
sched_active_pid = my_next_pid;
next_thread->status = STATUS_RUNNING;
sched_active_pid = next_thread->pid;
sched_active_thread = (volatile tcb_t *) next_thread;
DEBUG("scheduler: next task: %s\n", my_active_thread->name);
DEBUG("scheduler: done, changed sched_active_thread.\n");
if (my_active_thread != sched_active_thread) {
if (sched_active_thread != NULL) {
if (sched_active_thread->status == STATUS_RUNNING) {
sched_active_thread->status = STATUS_PENDING;
}
}
sched_set_status((tcb_t *)my_active_thread, STATUS_RUNNING);
}
sched_active_thread = (volatile tcb_t *) my_active_thread;
DEBUG("scheduler: done.\n");
return 1;
}
#if SCHEDSTATISTICS