[C] Misurare durata comando

[magix2003]

Ciao a tutti,

all'università ci hanno dato da fare un esercizio, che consiste di scrivere un programma che dato come parametro un comando di shell, conti i secondi di durata del processo. Io ho abozzato qualcosa del genere:

#include <stdio.h>
#include <stdlib.h>
#include <syscall.h>
#include <unistd.h>
#include <time.h>


int main(int argc , char *argv[])  {
	time_t init;
	time_t delta;
	int pid = fork();
	if (pid == 0) {
		init = time(NULL);
		execlp(argv[1],argv[1],0);
	} else {
		
		time_t after = time(NULL);
		delta = after - init;
		printf("The program has durato %i\n",delta);
	}
	
	return 0;
}

Ma non funziona, cioé stampa dei tempi assurdi. Qualcuno può darmi un hint per favore? Non sono molto esperto di fork e cose del genere quindi abbiate pazienza...
Grazie

[labrosan]

Il tempo si misura così:

time_t inizio; // tempo iniziale
time_t fine; // tempo finale

time(&inizio);

... codice ...

time (&fine);

durata=fine-inizio;

[magix2003]

Grazie per la risposta, ma il mio prblema non è tanto come usare la funzione time, ma come generare il processo figlio.

[Gandalf_BD]

la variabile init tu la inizializzi nel processo figlio...
questo fa si che il padre non ne conosca il valore...
in pratica, quando tu fai una fork(), vengono create due istanze separate dello stesso programma... il fatto è che se tu cambi la variabile init nell'istanza del figlio, questo cambiamento non viene visto dal padre...

[magix2003]

Originariamente inviato da Gandalf_BD

la variabile init tu la inizializzi nel processo figlio...
questo fa si che il padre non ne conosca il valore...
in pratica, quando tu fai una fork(), vengono create due istanze separate dello stesso programma... il fatto è che se tu cambi la variabile init nell'istanza del figlio, questo cambiamento non viene visto dal padre...

Ok, grazie, però non funziona ancora, perchè adesso prima stampa il tempo trascorso ancor prima di eseguire il comando, quindi il delta è 0.

#include <stdio.h>
#include <stdlib.h>
#include <syscall.h>
#include <unistd.h>
#include <time.h>


int main(int argc , char *argv[])  {
	time_t init;
	time_t delta;
	int pid = fork();
	init = time(NULL);
	if (pid == 0) {
		execlp(argv[1],argv[1],0);
	} else {
		//printf("padre");
		time_t after = time(NULL);
		delta = after - init;
		printf("The program has durato %i\n",delta);
	}
	
	return 0;
}

Forse il problema è che prima viene eseguito il padre e poi il figlio. Come posso evitare questo problema?

[tglman]

domanda ??
maperche segui una fork() ??

nn sarebbe sufficente:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>


int main(int argc , char *argv[])  {
	time_t init = time(NULL);
	execlp(argv[1],argv[1],0);
	printf("The program has durato %i\n",	time(NULL) - init);
	return 0;
}

[magix2003]

Originariamente inviato da tglman

domanda ??
maperche segui una fork() ??

nn sarebbe sufficente:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>


int main(int argc , char *argv[])  {
	time_t init = time(NULL);
	execlp(argv[1],argv[1],0);
	printf("The program has durato %i\n",	time(NULL) - init);
	return 0;
}

Grazie anche a te per la risposta. Però neanche così funziona, perché prima mi stampa la stringa e generalmente è il tempo è 0, poi esegue il programma....

[beppegrillo]

Innanzitutto, se intendi condividere variabili tra due processi, non volendo utilizzare meccanismi di comunicazione varie, le variabili devono essere di tipo globale e non privato come hai fatto.
Per il problema specifico invece, è sbagliato fare un semplice if, perchè il padre appena verrà eseguito entrerà nell'else, non curandosi del processo lanciato dal figlio.
Puoi risolvere facendo una waitpid sul figlio, attendendo quindi che il figlio termini la sua esecuzione, e poi ti fai i tuoi calcoli.

[tglman]

Si hai ragione perche execlp prende il controllo del programma!!!
e nn ritorna il controllo a meno che nn vada male!!

[tglman]

Forse trovata una soluzione!!

Devi mantenere la fork, ma nella parte che gestisce il count del tempo devi aspettare che tutti i processi finiscono!!
cioe:

#include <stdio.h>
#include <stdlib.h>
#include <syscall.h>
#include <unistd.h>
#include <time.h>


int main(int argc , char *argv[])  {
	time_t init = time(NULL);
	time_t delta;
	int pid = fork();
	if (pid == 0) {
		execlp(argv[1],argv[1],0);
	} else {
                wait();//od un waitpid() nn so prova ;)
		printf("The program has durato %i\n",time(NULL) - init);
	}
	
	return 0;
}

[magix2003]

Originariamente inviato da tglman

Forse trovata una soluzione!!

Devi mantenere la fork, ma nella parte che gestisce il count del tempo devi aspettare che tutti i processi finiscono!!
cioe:

#include <stdio.h>
#include <stdlib.h>
#include <syscall.h>
#include <unistd.h>
#include <time.h>


int main(int argc , char *argv[])  {
	time_t init = time(NULL);
	time_t delta;
	int pid = fork();
	if (pid == 0) {
		execlp(argv[1],argv[1],0);
	} else {
                wait();//od un waitpid() nn so prova ;)
		printf("The program has durato %i\n",time(NULL) - init);
	}
	
	return 0;
}

Ok così funziona grazie. La wait() da quello che ho capito aspetta la terminazione del processo padre giusto?

[tglman]

Veramete Aspetta che un figlio termini......
per maggiori informazzioni:
http://digilander.libero.it/uzappi/C...ioni/wait.html

ciao e buon divertimento

puoi provarla anche senza una fork sa curiosita .....