Processi di 2 tipi diversi [C]

[MrSwat360]

Ciao a tutti ragazzi, sto facendo il progetto per l'esame di S.O. e riporto quanto scritto sulla traccia:

Si intende realizzare la simulazione di una “società” di individui. In questa simulazione `e presente
una “popolazione” di processi di due tipi. Sulla base di certe regole, illustrate di seguito nel dettaglio, i processi
generano dei figli che entrano a far parte della popolazione.
Processi Sono presenti processi di tre tipi:
1. “Gestore”, che gestisce la simulazione e i vari eventi, e genera gli individui;
2. processi di tipo “A”;
3. processi di tipo “B”.
Ogni processo individuo `e caratterizzato da:
• un tipo (“A” o “B”);
• un nome codificato da una stringa di caratteri;
• un genoma codificato da un unsigned long.
All’inizio, il gestore crea un numero init_people≥ 2 (per esempio 20) di individui.
Per ogni individuo creato, vengono determinati casualmente:
• il suo tipo: “A” o “B”;
• il suo nome: un carattere maiuscolo (da “A” a “Z”);
• il suo genoma: un unsigned long casuale da 2 a 2+genes.
La creazione degli individui avviene con fork e poi una execve del figlio

Non riesco a capire cosa intende per tipo A e B, e come conferire quelle caratteristiche, devo creare una struttura???

Grazie a tutti.
Sergio

[MrSwat360]

-

[MrSwat360]

crei una struttura con i parametri in elenco, inizializzata in maniera randomica come dice nelle specifiche, e la passi di volta in volta come parametro al thread che viene creato dal gestore.

Grazie mille per la risposta innanzitutto.
Se creo una struttura e le do il nome process, non posso inizializzarla una sola volta?

typedef structure {
char tipo;
*char nome;
unsigned int genoma;
} process;

int main()
for(int i=0; i < init_people ; i++)
process = { rand() % 67 + 65 , rand() % 91 + 65 , rand() % 100 + 2 }


Cosi facendo process non viene ogni volta sostituito con valori nuovi?

[MrSwat360]

il gestore passera' un puntatore a process ad ogni thread che viene generato, per cui se aggiorni la stessa struttura, modificherai i parametri degli altri thread che hai gia' generato. devi percio' fare una cosa del genere:


structure {
char tipo;
*char nome;
unsigned int genoma;
} process[init_people];

int main() {
for(int i=0; i < init_people ; i++) {
process[i] = initit_process_struct( rand() % 67 + 65 , rand() % 91 + 65 , rand() % 100 + 2 );
crea_thread( ..., &process[i] ... );
}
}


Le 2 funzioni in grassetto che hai aggiunto cosa dovrebbero fare??
In crea_thread devo inserire la fork?

[sottovento]

Attenzione - per quanto sembri assurdo, la traccia parla di processi, non di thread (riporta espressamente che e' necessario usare fork + exec).

Comunque l'approccio suggerito da Antonio e' corretto. Fai solo attenzione a creare processi e non thread per evitare di andare off topic

[MrSwat360]

giusto, non avevo notato. comunque la soluzione che ho delineato, come dici tu, e' adattabile anche a quest'altro caso. anzi, probabilmente si puo' fare in maniera piu' semplice poiche' i processi non condividono lo stesso spazio di indirizzi.

Ragazzi ho risolto così :

int init_people = 0;
int *ip;
pid_t my_pid;
typedef struct process
{
char tipo;
char nome[100];
unsigned int genoma;
} t_process;
t_process informations[20];

void initialize(t_process c1){
int l=0;
c1.tipo = '\0';
c1.nome[l] = '\0';
c1.genoma = 0;
}
void stampainfo(t_process c1)
{
printf("Tipo: %c, Nome: %s, Genoma : %u\n", c1.tipo, c1.nome, c1.genoma);
}

int i,j,z, k = 0, genes = 0;
int main(int argc, char *argv[])
{
char *newargv[] = { "A", "B", NULL };
char *newenviron[] = { NULL };
my_pid = getpid();
char* buf = (char*) malloc(sizeof(long));
printf("Inserisci un numero di processi iniziali: ");
scanf("%d", &init_people);
printf("Inserisci un numero di genoma: ");
scanf("%d", &genes);
ip= (int*) malloc(init_people*sizeof(t_process*));
srand(time(NULL));
for(i=0; i< init_people; i++)
{
informations[i].tipo = 65 + rand() % 2;
informations[i].nome[k]=(char)65 +rand() % 26;
informations[i].nome[k+1]= '\0';
informations[i].genoma = 2 + rand() % (genes+2);
}
for(j=0; j< init_people; j++)
stampainfo(informations[j]);
switch(fork())
{
case -1:
error("Errore nella creazione del processo ", my_pid);
case 0:
sprintf(buf, "%d", my_pid);
switch(fork())
{
case -1:
error("Errore nella creazione dei processi", my_pid);
case 0:
printf("\n---> Comincio a creare i processi!\n");
execve("./Processo", newargv, newenviron);
error("Errore eseguendo un processo A", my_pid);
default:
sleep(1);
execve("./Processo", (newargv +1), newenviron);
error("Error eseguendo un processo B", my_pid);
}
}
return 0;
}


Adesso dovrei utilizzare la execve ma non capisco come..

[sottovento]

Ciao
fai conto di scrivere 3 programmi diversi = 3 applicazioni eseguibili diverse (una e' la tua master application, una e' il programma A, una e' il programma B). Concettualmente e' piu' semplice se pensi a 3 programmi distinti.
La traccia non dice nulla riguardo ai programmi A e B, quindi probabilmente te la puoi cavare semplicemente con una stampa dei parametri. In questo caso, A e B sono uguali ma considerali concettualmente distinti.

Sei arrivato correttamente alla fork(). L'ultimo passo e' quindi quello di chiamare la exec() (nella versione che preferisci) lanciando A o B invece di Processo. Tutto qui.

Fai pero' attenzione che dovrai passare la serie di argomenti che hai calcolato, cosi' che i programmi A/B li possano usare. Per ora li hai calcolati ma non li passi a nessuno, quindi non saranno disponibili al chiamato.

Una raccomandazione molto importante: ho visto che hai fatto il controllo sul fatto che la fork() possa fallire ed hai fatto benissimo.
Analogamente pero' dovresti fare il controllo sul fatto che la malloc() vada a buon fine. E' piu' importante di quanto pensi perche' nel caso la malloc() fallisca andrai in crash e passerai parecchio tempo a dire parolacce prima di trovare l'errore (specialmente nel caso di programmi voluminosi) ed io ci tengo che tu vada in paradiso :D

Infine, una pignoleria: informations non esiste in inglese, rimuovi la s finale. Certo non cambia il programma ma si presenta molto meglio

[MrSwat360]

PRESUPPOSTO che si deve parlare obbligatoriamente di processi(NON thread), nello specifico n processi figlio generati da un padre, mi serve solo capire come realizzare questa frase:
Dopo la creazione dei processi “A” vengono pubblicate le loro informazioni (genoma,
PID e/o altre informazioni ritenute utili). Tale pubblicazione avviene su apposita struttura dati accessibile anche
ai processi “B”. Dopo la pubblicazione delle proprie informazioni, i processi “A” rimangono in attesa di essere
contattati da processi “B”

Ho la consegna entro le 24:00 di oggi, sono disperato :help: :help: :help: :help: :help: :help: