[c/c++]Generare un processo e se non termina entro 5 secondi lo uccido

[anx721]

Salve,

quello che devo fare è la seguente cosa: devo eseguire un certo numero di computazioni; ognuna di queste deve essere eseguita in un processo separato. Un nuovo processo non puo essere creato prima che il precedente si sia concluso, e ogni processo deve concludersi ad esempio entro 5 secondi, se no lo si uccide e si passa a generare il successivo. Io ho fatto cosi:

- ho registrato una funzione handler per il segnale SIGALRM, che posso generare a mio piacimento, specificando dopo quanti secondi deve esserci il segnale.

- eseguo la fork, registrandomi il pid del processo creato; quindi chiamo la alarm(5) per generare l'allarme tra 5 secondi, dopodichè chiamo waitpid(pid, ...) per attendere la terminazione del processo. Se il processo non termina entro 5 secondi, scatta l'allarme, e la funzione handler esegue una kill(pid) per uccidere il processo che non è terminato.

Pero potrebbe esserci un inconveniente; supponiamo che debba generare 10 peocessi uno dopo l'altro; se imposto il codice in questo modo:

for(int 1 = 0; i < 10; i++)
      pid = fork();
      alarm(5);
      if(pid == 0)
             break;
      wait(pid....);

potrebbe verificarsi che l'allarme dell'iterazione precedente venga a scattare proprio subito dopo la fork ma prima della nuova chiamata ad alarm(5): in questo modo il processo appena creato sarebbe ucciso senza che siano passati i 5 secondi. Allora potrei mettere alarm(5) prima della fork:

CODE]
for(int 1 = 0; i < 10; i++)
alarm(5);
pid = fork();
if(pid == 0)
break;
wait(pid....);
[/code]

In questo modo se un processo viene ucciso questo è per forza quello generato subito dopo la chiamata ad alarm() e non uno precedente (perche se il precedente non fosse terminato sarei ancora bloccato nella wait). Pero non posso avere la certezza che l'istruzione:

pid = fork();

venga conclusa entro 5 secondi: se cosi non avviene avrei che il segnale della precedente alarm() potrebbe essere generato quando il figlio ancora non è stato creato e quindi sarebbe sprecato, con la conseguenza che se non terminasse non saprei come ucciderlo perche il relativo allarme è gia avvenuto.

Sono giusti i miei ragionamenti? Potrei eliminare il problema della prima versione concludendo il cilco for con una chiamata alarm(0)?

Tra le due versioni penso che la seconda sia piu sicura, ma come posso impostare la cosa per avere l'assoluta certezza di quel che deve succedere? Ci sono funzioni alternative e piu specifiche che posso usare? C'è ad esempio una funzione che dato il pid mi dice se il processo relativo a quel pid e terminato o no?

Grazie, ciao.

[anx721]

Ho trovato sulla documentazione a proposito di alarm(seconds):

If seconds is 0, a pending alarm request, if any, is cancelled.

Quindi se cancello la richiesta di allarme subito dopo la terminazione di un processo, un allarme dell'iterazuine precedente non dovrebbbe interferire con la successiva iterazione:

for(int 1 = 0; i < 10; i++)
      pid = fork();
      alarm(5);
      if(pid == 0)
             break;
      wait(pid....);
      alarm(0);

Dite che va bene cosi? O ci sono dei dettagli che mi sfuggono?

[ilsensine]

Hai una piccola race condition tra la wait e la alarm(0), ma è assolutamente innocua. Va bene come hai fatto.

[anx721]

Originariamente inviato da ilsensine
Hai una piccola race condition tra la wait e la alarm(0), ma è assolutamente innocua. Va bene come hai fatto.

Se hai tempo me la spieghi?

Se ti riferisci al fatto che potrebbe scattare l'allarme precedente dopo la wait ma prima del nuovo alarm(0), verrebbe eseguita la kill sul pid sul processo appena terminato, che mi sembra non dia problemi.

[ilsensine]

Se un processo termina regolarmente poco prima dei 5 secondi, la wait termina e viene eseguito successivamente alarm(0). Se tra la wait e la alarm scadono i 5 secondi, viene generato un SIGALRM dopo la wait (quindi a processo finito) ma prima della alarm(0). E' un evento a probabilità quasi nulla, ma possibile (e comunque assolutamente innocuo).