Newsgroup: it.comp.lang.c
Titolo: Problema numeri casuali in processi figli

Salve a tutti, ho un piccolo problema, quando faccio una fork di un
processo e genero ad esempio 3 processi figli ed ogni figlio mi genera
un numero casuale mi capita sempre che i 3 processi abbiano sempre lo
stesso valore, per esempio se il processo 1 genera due numeri casuali
(16, 28) i processi 2 e 3 mi generanno pure (16, 28), se poi ritorno al
processo 1 (mettiamo per ipotesi che i processi vengano lanciati in
ciclo infinito) e mi genera 34 56 gli altri mi generano anche 34 e 56.
Le variabili in cui memorizzo i numeri sono interne al processo figlio,
la sruttura è più o meno questa:
for(i=0; i<3;i++){
if(fork()==0)
figlio();
}
figlio(){
while(1){
int cas=rand()%100;
nt cas=5+rand()%50;
}
}
Perchè questo comportamento?
Grazie a tutti, ciao ciao.

 
Hai provato a cambiare il seed dei numeri casuali?

Forse ho scritto male, non vengono uguali questi:
int cas=rand()%100;
nt cas2=5+rand()%50;
cas!=cas2 questo funziona, vengono uguali questi (25 50)
cas processo 1 (25) uguale cas processo 2  (25) uguale cas processo 3
(25)
cas2 processo 1  (50)  uguale cas2 processo 2 (50) uguale cas2 processo
3 (50)
sempre e comunque ripetuti nel tempo, se poi rieseguo il ciclo e rivado
a calcolare cas e cas2 ottengo altri due valori (34 12) però:
cas processo 1 (34) uguale cas processo 2 (34) uguale cas processo 3
(34)
cas2 processo 1 (12) uguale cas2 processo 2 (12) uguale cas2 processo 3
(12)
Come faccio a far cambiare il seed per ogni figlio?
Grazie, ciao ciao.

L'ho aggiunto ed ora tutto va bene, grazie ancora.
Scusa un'altra cosa volevo chiedere riguarda la comunicazione tra due
processi trami pipe senza nome.
Ora un processo A calcola una media da dei dati che legge da una pipe
con nome, i dati letti sono corretti.
Un altro processo B comunica con A tramite una pipe senza nome, ora
come faccio a fare in modo che A non si blocchi quando è in wait sul
semaforo atteaverso cui B manda la richiesta di voler ricevere la
media? Nel processo A che sotto allego il semaforo per le pipe senza
nome non è implementato.
Io per adesso, provando solo un comando, faccio sempre scrivere ad A la
media sulla pipe così appena B vuole leggerla la legge, però in
questo modo si hanno più medie una dietro l'altra e non c'è quella
attuale ma si legge una media vecchia, ma nonostante questo ho un altro
problema, la media letta è sballata.
Io faccio scrivere un intero sulla pipe da A e faccio leggere a B un
intero solo che il numero è sballato mi arrivano cose tipo 377851561
quando dovrebbe essere un valore piccolo tra 5 e 10, come è possibile?
Ancora altre due domande, come mai se metto delle printf non mi viene
stampato nulla a video, se non dopo molto tempo o a seguito di errori,
invece se stampo a video con una write(1,....) mi viene stampato subito
quello che voglio?
Che differenza c'è tra una wait ed una sleep? Quale consuma meno
risorse?
Grazie, infinite, ciao ciao.
Allego di seguito il codice dei due processi.
Processo A (NON C'E' SEMAFORO PIPE SENZA NOME):
void controllore(){
int i;
char buffer;
int t, count, casuale, durata;
int media;
int ttot;
close(pippa_interna[LETTURA]);
while(1){
count++;
i=count%3;
char c='t';
//semaforo pipe con nome
write(sem[i], &c, 1);
//pipe con nome da cui si legge
read(pip[i], &durata, sizeof(durata));
ttot+=durata;
media=(int)(ttot/count);
durata=0;
casuale = 10 + rand()%10;
//scrittura sulla pipe senza nome
write(pippa_interna[SCRITTURA], &media, sizeof(media));
sleep(casuale);
}
}
Processo B(NON C'E' SEMAFORO PIPE SENZA NOME)::
void tester(){
int comando;
int media=0;
char cc[255], inv;
close(pippa_interna[SCRITTURA]);//pipe senza nome usata solo il lettura
while(1){
write(1,"\n->",strlen("\n->"));
scanf("%d",&comando);
switch(comando){
case 0:
exit(0);
break;
default:
read(pippa_interna[LETTURA],&media, sizeof(media));//leggo dalla pipe
senza nome
snprintf(cc, sizeof(cc), "La media Ã¨: %d", media);
write(1,cc, strlen(cc));
break;
}
memset(cc, 0, sizeof(cc));
}
close(pippa_interna[LETTURA]);
}

 


Ti ringrazio, ora però non capisco solo una cosa, perchè il valore
che scrivo sulla pipe mi viene tornato con un numero astronomico tipo
376655667 quando dovrebbe essere un numero tra 5 e 10?
Grazie, ciao ciao

Scusa se scrivo ancora, ma io per le pipe utilizzo queste funzioni:
void semaphore_init(int* sw){
if(pipe(sw)==-1){
printf("error");
exit(-1);
}
}
void semaphore_signal(int* sw){
if(write(sw[1], "X", 1)!=1){
printf("error");
exit(-1);
}
}
void semaphore_wait(int *sw){
char buffer;
if(read(sw[0],&buffer,1)!=1){
printf("error");
exit(-1);
}
}
void semaphore_del(int *sw){
if(close(sw)==-1 || close(sw)==-1){
 printf("Error");
 exit(-1);
  }
}
Come faccio a rendere la funzione semaphore_wait non bloccante, 
relativamente ad un solo semaforo? La select come funziona?
Creo un readset o un writeset;
imposto la select con Select(mxfd+1, readset,writeset,timeout);
per verificare se è attivo un certo readset metto un if(FD_ISSET(file 
descriptor, readset o writeset a seconda dei casi);
se è attivo mi torna 1 entra nell'if e poi alla fine non ho capito cosa devo 
inserire nel readset, potreste spiegarmelo?
Grazie, ciao ciao. 

In definitiva l'unica cosa che mi interessa sapere è:
come faccio a fare una read non bloccante da una pipe senza nome
int pipeS[2];
pipe(pipeS);
read(pipeS[0], intero, sizeof(intero)); //come faccio a fare questa
read non bloccante?
Grazie, ciao ciao.


Prima di fare un read() chiama fcntl() per cambiare il modo di lavoro 
della pipe.  Controlla se il SO su cui lavori lo permette.
fcntl(pipeS[0], F_SETFL, O_NONBLOCK);
Ciao
Giovanni
