[C] Allocazione dinamica...

[Ed_Bunker]

Ciao, ho un problemuccio urgente da capire...
Si tratta di realizzare un semplice server che ad ogni
richiesta ricevuta mediante pipe crei u proceso ad hoc
per svolgere una certa funzione calcolando il tempo di
esecuzione impiegato dal processo figlio. In partciolare
dovrei fare qualcosa di questo genere:

...
struct timeval * start;
struct timeval * end;
long int med;
...
int main(int argc, char * argv[])
{
...
/*Per gestire il sigchld...*/
struct sigaction new, old;
new.sa_handler = deadHandler;
if(sigaction(SIGCHLD, &new, &old) == -1)
{
perror("Errore nella sigaction");
exit(-1);
}

while (TRUE)
{
/*RICEZIONE DELLE RICHIESTE*/
int pid;
start = (struct timeval*) malloc (sizeof(struct timeval));
end = (struct timeval*) malloc (sizeof(struct timeval)); 
gettimeofday(start,NULL);
pid = fork();
if (pid ==0)/*Figlio*/
{
funzione1(...qui passo i parametri giusti...);
exit(0);
}
/*Il padre torna a ricevere richieste...*/
}

/*Routine per la gestione del segnale sigchld...*/
void deadHandler(int sig)
{
getimeofday(end,NULL);
long int execTime = (end->tv_sec - start->tv_sec) * 1000000 + 
                    (end->tv_usec - start->tv_usec);
med = ALPHA * med + (1-ALPHA) * execTime;
}

Il mio problema e' questo:
il padre non sa a priori quando entrera' nella routine per
gestire il sigchld. Pertanto vorrei sapere questo: quando
entro nella deadHandler(...) la PRIMA volta, accedendo alla
varibile START, faccio riferimento alla sua PRIMA allocazione
(E quindi al suo primo valore)?! E quindi quando accedo alla
routine la SECONDA volta faccio riferimento alla SECONDA
allocazione della variabile oppure no ?!? E cosi' via...
In altre parole quando entro nella routine di gestione del
sigchld la PRIMA volta ed accedo a start, quest'ultima potrebbe essere stata sovrascritta perche' nel frattempo il
server ha ricevuto una (o piu') ulteriore richiesta e quindi
ha dato un nuovo valore a start ?! Oppure il fatto che
utilizzi la allocazione dinamica mi cautela da questo
"problema". (In pratica dovrebbe succedere qualcosa di simile a quello che accade nella ricorsione per fare in modo che gli
effetti siano quelli "desiderati"...)

Scusate se ho scritto una marea di roba e se, oltretutto...
sono stato pure poco chiaro...

thks

[MMarzia]

Originariamente inviato da Ed_Bunker
Scusate se ho scritto una marea di roba e se, oltretutto...
sono stato pure poco chiaro...

thks

più che altro la prossima volta non esagerare con la grandezza del carattere

[Ed_Bunker]

Originariamente inviato da MMarzia
più che altro la prossima volta non esagerare con la grandezza del carattere

Mi hai beccato mentre lo stavo modificando. Alla fine l'avevo messo a 4. E mi hai fatto subito il "cazziatone"...

[anx721]

La deadHandler viene chiamata dal processo figlio? Cioè nel ramo (pid == 0) del l'if? Se è cosi dovresti tenere presente che il figlio è un processo separato dal padre e quindi i due lavorano in zone di memoria completamente indipendenti; questo significa che il valore di start a cui accede il figlio è quello che tale variabile aveva prima della fork, e anche se nel frattempo il padre ha nuovamente allocato spazio per start, lo ha allocato nel suo spazio di memoria, non in quello del figlio, in cui start resterà immodificato.

[Ed_Bunker]

Originariamente inviato da anx721
La deadHandler viene chiamata dal processo figlio? Cioè nel ramo (pid == 0) del l'if? Se è cosi dovresti tenere presente che il figlio è un processo separato dal padre e quindi i due lavorano in zone di memoria completamente indipendenti; questo significa che il valore di start a cui accede il figlio è quello che tale variabile aveva prima della fork, e anche se nel frattempo il padre ha nuovamente allocato spazio per start, lo ha allocato nel suo spazio di memoria, non in quello del figlio, in cui start resterà immodificato.

La deadHandler(...) viene chiamata dal padre. Il mantenimento dei tempi di esecuzione e' "sua esclusiva". I processi figli hanno solo il compito di svolgere la funzione.