[C]Aiuto su programma con PThread e schedulazione thread

[erkk84]

Ciao a tutti, sono in cerca d'aiuto per la comprensione di alcuni argomenti riguardanti il mondo del RT, in particolare i PThreads e la loro schedulazione; premetto che singolarmente e nella teoria mi sembra di averli capiti, è la loro applicazione che mi sta dando problemi.
Sto cercando di capire un programmino che li integra, sostanzialmente scrive a video su terminale le coordinate di una pallina in movimento; non posto tutto il codice (anche perchè è suddiviso in file), ma solo quelle parti che non penso di aver capito bene.
Cominciamo dal main:
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <sys/time.h>
#include <time.h>
#include <stdint.h>

#include "output.h"
#include "system.h"
#include "control.h"

int main(int argc, char *argv[])
{
int res;
void *returnvalue;
pthread_t system_id, control_id, output_id;
/*const*/ double system_period = 0.005, control_period = 0.2;
/*const*/ int output_period = 300;

printf("Chiamo system_id\n");
res = pthread_create(&system_id, NULL, system_body, &system_period); //crea un pthread, al quale è associato un id, attr di default (NULL), funzione
//col codice (in system.c) che deve eseguire e l'argomento passato alla funzione
// (&system_period)
if (res) {
perror("pthread_create system");

return -1;
}

printf("Chiamo control_id\n");
res = pthread_create(&control_id, NULL, control_body, &control_period); //idem come sopra; funzione in control.c
if (res) {
perror("pthread_create control");

return -1;
}

printf("Chiamo output_id\n");
res = pthread_create(&output_id, NULL, output_body, &output_period); //idem come sopra; funzione in output.c
if (res) {
perror("pthread_create output");

return -1;
}

pthread_join(system_id, &returnvalue);

pthread_join(control_id, &returnvalue);

pthread_join(output_id, &returnvalue);


return 0;
}

i body dei pthreads sono:
void *system_body(void *p)
{
printf("Chiamo system_body\n");
double dt = *(double *)p; //p=0.005
struct periodic_task *t;
double th;
int j=0;

r = 1;
r1 = 0;
th = 0;
t = start_periodic_timer(0, 1000000.0 * dt);
while(j<20) {
th = c();
//printf("THETA: %d\n", (int)th);
r1 = f1(r1, th, dt);
r = f(r, r1, dt);
wait_next_activation(t);
j++;
}

return NULL;
}


void *control_body(void *p)
{
printf("Chiamo control_body\n");
double dt = *(double *)p;
struct periodic_task *t;
double u, u1;
const double kp = -3, kd = -3;
int i;

u = 0; u1 = 0;
i = 0;
t = start_periodic_timer(0, 1000000.0 * dt);
u1 = position();
while(1) {
wait_next_activation(t);
i++;
u = position();
theta = kp * (ref(dt * i) - u) - kd * (u - u1) / dt;
u1 = u;
}


void *output_body(void *p)
{
printf("Chiamo ouput_body\n");
int dt = *(int *)p;
struct periodic_task *t;
int i;

i = 0;
t = start_periodic_timer(0, 1000 * dt);
while(1) {
printf("%lf\t%lf\n", dt / 1000.0 * i, position());
fflush(stdout);
wait_next_activation(t);
i++;
}

Questi ultimi si trovano in file diversi; lasciate stare le funzioi chiamate internamente, quelle non mi danno particolari problemi, fanno dei loro calcoli matematici.

In ultimo, la parte relativa alle chiamate di sistema.

extern int clock_nanosleep(clockid_t __clock_id, int __flags,
__const struct timespec *__req,
struct timespec *__rem);

struct periodic_task {
struct timespec r;
int period;
} ;
#define NSEC_PER_SEC 1000000000ULL

static inline void timespec_add_us(struct timespec *t, uint64_t d)
{
d *= 1000;
d += t->tv_nsec;
while (d >= NSEC_PER_SEC) {
d -= NSEC_PER_SEC;
t->tv_sec += 1;
}
t->tv_nsec = d;
}

void wait_next_activation(struct periodic_task *pd)
{
clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &pd->r, NULL);
timespec_add_us(&pd->r, pd->period);
}

struct periodic_task *start_periodic_timer(uint64_t offs, int t)
{
struct periodic_task *task;

task = malloc(sizeof(struct periodic_task));
clock_gettime(CLOCK_REALTIME, &task->r);
timespec_add_us(&task->r, offs);
task->period = t;

return task;
}

Il problema è: non riesco a capire come vengono gestiti i vari PThreads; cioè, io ad esempio avrei detto che viene chiamato prima il body "System", invece viene chiamato prima il control, poi l'output e poi il System...e questo è uno dei problemi;
Poi, non riesco a capire la schedulazione dei processi con le varie chiamate a start_periodic_timer, wait_next-activation, ecc...

C'è qualche buon'anima che mi potrebbe aiutare in questo senso?Magari allego il pacchetto dei file completii per avere un'idea migliore di come è strutturato il programma.

Grazie