Hi everybody
Thanks Bernhard
Itīs clear. You said
With RTL, "real time tasks" have more in common with "threads"
than with "processes" since they run in the same address space.
(as like "kernel-threads" a running in the same address space
as the kernel itself).
This answer my question, but ...
iīm doing some experiences in programming rtlinux modules, and make myself
familiar with the api.
I want to test the scheduler. I understood that itīs fixed priorities. So,
i run a module that create three threads with diferents priorities, say 1,
2 and 3.
I īve done the questions about the differents between threads and tasks,
because i want to know what happen with the priorities in tasks and
threads.
Supose i want to do three things in a periodic form. I assign each of
them to a thread with different priority. Letīs say priorities 1, 2 and
3.
I unsdestood, reading docs and mailing list, that the scheduler in
rtlinux is a priority one. Letīs say, that if i run the three threads in
a periodic form, the one with priority executes first, then the one with
priority 2 and so on. If, during the execution of thread 2, thread 1
need the cpu because of its period, the scheduler should interrupt the
execution of thread 2 and start executes thread 1, because it priority.
The same things happen if itīs running thread 3 and thread 2 need to
run.
Is it true? I donīt know if iīm wrong. I did a code with three threads
that is not working as iīve just described.
Then i wondered if the best way to make things work like i īve just
described is using threads or using rtl tasks??
Perhaps threads donīt support priorities and tasks do.
Well, all your comments are wellcome.
I donīt need that you explain me the different between thread and
process, i know them. My doubts are rtl especific. I try to make things
work in a manner that may be is incorrect.
Thanks everybody.
worm
I attach the code ......
#include <rtl.h>
#include <rtl_fifo.h>
#include <rtl_sync.h>
#include <time.h>
#include <pthread.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/version.h>
#include <linux/errno.h>
#include <rtl_sched.h>
#define TIME_FIFO 1
#define FIFO_SIZE 1024*20
#define THREAD_PERIOD1 100000 /* ns, ahora esta en .1s */
#define THREAD_PERIOD2 70000 /* ns, ahora esta en .07s */
#define THREAD_PERIOD3 50000 /* ns, ahora esta en .05s */
#define DURACION_THREAD1 20000
#define DURACION_THREAD2 30000
#define DURACION_THREAD3 20000
pthread_t thread1,thread2,thread3;
struct datos {
int threadnumber;
long num;
hrtime_t tiempo;
};
/*-----------------------------------------------------------------------*/
/*
thread_code1
*/
/*-----------------------------------------------------------------------*/
/* Esta rutina la ejecuta el thread1 */
void * thread_code1(void *arg)
{
struct datos to_fifo1;
hrtime_t t_entrada,tiempo,diferencia;
int i;
struct sched_param p1;
p1 . sched_priority = 1;
pthread_setschedparam (pthread_self(), SCHED_FIFO, &p1);
pthread_make_periodic_np (pthread_self(), gethrtime(),
THREAD_PERIOD1);
for (i=1;i<=200;i++)
{
t_entrada=gethrtime();
diferencia=t_entrada - t_entrada;
rtl_printf("Ejecutando thread 1 en %d \n",t_entrada);
while (diferencia<=DURACION_THREAD1)
{
tiempo=gethrtime();
to_fifo1.threadnumber = 1;
to_fifo1.num = i;
to_fifo1.tiempo = tiempo;
rtf_put(TIME_FIFO, (char *)&to_fifo1, sizeof(to_fifo1));
diferencia = tiempo - t_entrada;
}
pthread_wait_np();
}
return 0;
}
/*-----------------------------------------------------------------------*/
/*
thread_code2
*/
/*-----------------------------------------------------------------------*/
/* Esta rutina la ejecuta el thread2 */
void * thread_code2(void *arg)
{
struct datos to_fifo2;
hrtime_t t_entrada,tiempo,diferencia;
int i;
struct sched_param p2; /* Parametros del threads, en principio solo nos
importa la prioridad. Por mas detalles ver el
tutorial de Posix thredas. */
p2 . sched_priority = 2;
pthread_setschedparam (pthread_self(), SCHED_FIFO, &p2);
pthread_make_periodic_np (pthread_self(), gethrtime(),
THREAD_PERIOD2);
for (i=1;i<=200;i++)
{
t_entrada=gethrtime();
diferencia=0;
rtl_printf("Ejecutando thread 2 en %d \n",t_entrada);
while (diferencia<=DURACION_THREAD2)
{
tiempo=gethrtime();
to_fifo2.threadnumber = 2;
to_fifo2.num = i;
to_fifo2.tiempo = tiempo;
rtf_put(TIME_FIFO, (char *)&to_fifo2, sizeof(to_fifo2));
diferencia=tiempo - t_entrada;
}
pthread_wait_np();
}
return 0;
}
/*-----------------------------------------------------------------------*/
/*
thread_code3
*/
/*-----------------------------------------------------------------------*/
/* Esta rutina la ejecuta el thread3 */
void * thread_code3(void *arg)
{
struct datos to_fifo3;
hrtime_t t_entrada,tiempo,diferencia;
int i;
struct sched_param p3; /* Parametros del threads, en principio solo nos
importa la prioridad. Por mas detalles ver el
tutorial de Posix thredas. */
p3 . sched_priority = 3;
pthread_setschedparam (pthread_self(), SCHED_FIFO, &p3);
pthread_make_periodic_np (pthread_self(), gethrtime(),
THREAD_PERIOD3);
for (i=1;i<=200;i++)
{
t_entrada=gethrtime();
diferencia=0;
rtl_printf("Ejecutando thread 3 en %d \n",t_entrada);
while (diferencia<=DURACION_THREAD3)
{
tiempo=gethrtime();
to_fifo3.threadnumber = 3;
to_fifo3.num = i;
to_fifo3.tiempo = tiempo;
rtf_put(TIME_FIFO, (char *)&to_fifo3, sizeof(to_fifo3));
diferencia = tiempo - t_entrada;
}
pthread_wait_np();
}
return 0;
}
/*-----------------------------------------------------------------------*/
/* init_module
*/
/*-----------------------------------------------------------------------*/
int init_module(void) {
rtf_create(TIME_FIFO,FIFO_SIZE);
pthread_create (&thread1, NULL, thread_code1, 0);
pthread_create (&thread2, NULL, thread_code2, 0);
pthread_create (&thread3, NULL, thread_code3, 0);
return 0;
}
/*-----------------------------------------------------------------------*/
/* cleanup_module
*/
/*-----------------------------------------------------------------------*/
void cleanup_module(void) { /* Descarga el modulo y deja las cosas
como estaban.*/
rtf_destroy(TIME_FIFO);
pthread_delete_np (thread1);
pthread_delete_np (thread2);
pthread_delete_np (thread3);
}
-- [rtl] ---
To unsubscribe:
echo "unsubscribe rtl" | mail [EMAIL PROTECTED] OR
echo "unsubscribe rtl <Your_email>" | mail [EMAIL PROTECTED]
---
For more information on Real-Time Linux see:
http://www.rtlinux.org/rtlinux/
