Do you have a question? Post it now! No Registration Necessary
Threaded View
Subject
- Posted on
Task scheduling
- 08-26-2003
- Mark Sokos
August 26, 2003, 5:49 pm
Reply
Save
Print
I am attempting to take a project using an embedded controller and its
own proprietary operating system and port it to linux. One of the
features of this operating system is that every task gets a set
reschedule interval, and the operating system automatically schedules
the task to run every time this interval expires. Here's an example:
main () {
rsi(25); /* set reschedule interval to 25 time ticks (1/4 second)
*/
while(1) { /* forever loop */
/* ... do task stuff here ... */
pause(); /* put task to sleep until the next reschedule interval
*/
}
}
What this will do is run everything inside the forever loop every 250
milliseconds.
What's the best way to do this under linux?
own proprietary operating system and port it to linux. One of the
features of this operating system is that every task gets a set
reschedule interval, and the operating system automatically schedules
the task to run every time this interval expires. Here's an example:
main () {
rsi(25); /* set reschedule interval to 25 time ticks (1/4 second)
*/
while(1) { /* forever loop */
/* ... do task stuff here ... */
pause(); /* put task to sleep until the next reschedule interval
*/
}
}
What this will do is run everything inside the forever loop every 250
milliseconds.
What's the best way to do this under linux?
Re: Task scheduling
Not quiete what the OP wants. Actually you need to do
while(1) {
gettimeofday(&tv,NULL);
/* do task stuff */
gettimeofday(&tv2,NULL);
usleep(25000-(tv2.tv_usec - tv1.tv_usec));
}
Otherwise the loop is not exectuted _every_ 25ms.
---
42Bastian
Do not email to snipped-for-privacy@yahoo.com, it's a spam-only account :-)
42Bastian
Do not email to snipped-for-privacy@yahoo.com, it's a spam-only account :-)
We've slightly trimmed the long signature. Click to see the full one.
Re: Task scheduling
What this OS does seems to be "cooperative multitasking" instead of
"preemptive multitasking" that is done in Linux.
Preemptive multitasking can interrupts each task at any time when an
event (e.g. an interrupt or inter-task communication) occurs or a time
slice expires. Now it does a rescheduling and reassigns priorities and
"running" flags. So another task can be made the running one. The
advantage is that at any given time (hopefully: see priority inversion)
the most important task is running. The downside is that you need to do
precautions if resources are used by multiple tasks. Usually you need to
use semaphores to prevent conflicts.
In cooperative multitasking systems the tasks can't be interrupted
unless they agree (e.g. call "pause()").
Thus moving your tasks to preemptive mode will be quite a lot of work,
especially if the code of the tasks is not yours, finding out the
critical resources.
But I think it's easy to leave everything as it is and do a cooperative
multitasking on top of Linux (if the performance (i.e. maximum latency
of this way is sufficient in that application).
Either
(1)
you use just a single Linux task for all your tasks and call the tasks
as functions that (kind of) return when they call "pause()"
or
(2) (perhaps even easier)
using a linux task for each of your tasks, you use a linux semaphore for
each task (linux semaphores are groups of semaphores anyway) that is
requested in the "pause()" function and thus might block the running
task. Before blocking, in the "pause()" function the semaphore of the
next task to be run will be decremented (or is it incremented ?) (linux
semaphores are "counting"). So that this task is going to be executed
(out of it's own "pause()" call. In the "pause()" code you can do
whatever scheduling you like to decide which semaphore to update and
thus make the most appropriate of your tasks do the next "cycle".
-Michael
"preemptive multitasking" that is done in Linux.
Preemptive multitasking can interrupts each task at any time when an
event (e.g. an interrupt or inter-task communication) occurs or a time
slice expires. Now it does a rescheduling and reassigns priorities and
"running" flags. So another task can be made the running one. The
advantage is that at any given time (hopefully: see priority inversion)
the most important task is running. The downside is that you need to do
precautions if resources are used by multiple tasks. Usually you need to
use semaphores to prevent conflicts.
In cooperative multitasking systems the tasks can't be interrupted
unless they agree (e.g. call "pause()").
Thus moving your tasks to preemptive mode will be quite a lot of work,
especially if the code of the tasks is not yours, finding out the
critical resources.
But I think it's easy to leave everything as it is and do a cooperative
multitasking on top of Linux (if the performance (i.e. maximum latency
of this way is sufficient in that application).
Either
(1)
you use just a single Linux task for all your tasks and call the tasks
as functions that (kind of) return when they call "pause()"
or
(2) (perhaps even easier)
using a linux task for each of your tasks, you use a linux semaphore for
each task (linux semaphores are groups of semaphores anyway) that is
requested in the "pause()" function and thus might block the running
task. Before blocking, in the "pause()" function the semaphore of the
next task to be run will be decremented (or is it incremented ?) (linux
semaphores are "counting"). So that this task is going to be executed
(out of it's own "pause()" call. In the "pause()" code you can do
whatever scheduling you like to decide which semaphore to update and
thus make the most appropriate of your tasks do the next "cycle".
-Michael
Site Timeline
- » gui for embedded linux
- — Next thread in » Embedded Linux
-
- » storing some bytes in CMOS-RAM
- — Previous thread in » Embedded Linux
-
- » Crosscompiling for ARM: reloc type R_ARM_ABS32 is not supported for PIC - ...
- — Newest thread in » Embedded Linux
-
- » Ten 860v Electric Eels Wire Themselves In Series
- — The site's Newest Thread. Posted in » Hobby Electronics Basics
-
XML Sitemap