[C] processi in Unix e syscall su File System

[daniele_dll]

Originariamente inviato da kentaromiura
un bel b-albero senno?

forse li è un po esagerato...il parser xml non è complicatissimo da usare (libxml2) quello...non zo

[}gu|do[z]{®©]

Originariamente inviato da kentaromiura
io farei un controllo sul numero di dir (d)
e poi avendo d/N ho le directory per ciascun processo..
se d/N*N != d allora aggiungo le dir rimanenti..
ovvero il resto di d/N :-p

for (i=0;i<N-1;i++)fork();
//controllo
fork()//last process..

allora.. il punto è questo [mi ci sono messo.. ho fatto più o meno tutto.. ma su questo ci devo riflettere meglio]:

se ho 10 path e e 3 processi, ogni processo deve fare 3 path.. e l'ultimo precesso farà il path in più.. insomma.. devo fare una cosa parallela..

come posso fa?

ci penso.. se avete un'idea veloce...

[kentaromiura]

recuperi il numero 10 prima di avviare le fork..
sai che n=3 numero di processi
10/3=3
ma 3*3=9
10-9=1
quindi avvierai n-1 fork da 3 e l'ultimo da 3+1

[}gu|do[z]{®©]

Originariamente inviato da kentaromiura
recuperi il numero 10 prima di avviare le fork..
sai che n=3 numero di processi
10/3=3
ma 3*3=9
10-9=1
quindi avvierai n-1 fork da 3 e l'ultimo da 3+1

sì.. ma come faccio la "fork da tre"..?

io ho:

n_proc //mettiamo 3
n_path //mettiamo 10

per_proc = n_path/n_proc;
for(i=0; i<n_proc; i++)
{
//faccio fork
//i figli che fanno?
}

in pratica devo dire ai figli: tu ti fai sti tre processi..
avendo "per_proc" che mi dice quanti path deve farsi ogni processo.. mi serve solo passargli il path da cui cominciare [i path stanno in un buffer.. uno per riga.. quindi basta dirgli parti dlala riga x e vai avanti per_proc]...

vabbè.. ci ragiono dopo.. ora sto su un'altra cosa

[daniele_dll]

dentro il for metti un IF per verificare se sei nel processo figlio o padre...se sei nel figlio richiami una funzione
se sei nel padre continui il for

magari dentro il ciclo for costruisci un'array che contiene le path da analizzare

cmq...mi sa che sta sbagliando ragionamento...ogni path non conterrà altre sotto path? quindi ogni processo figlio dovrà essere in grado di rifare tutta l'analisi

[}gu|do[z]{®©]

Originariamente inviato da daniele_dll


dentro il for metti un IF per verificare se sei nel processo figlio o padre...se sei nel figlio richiami una funzione
se sei nel padre continui il for

madddaaaaai?

magari dentro il ciclo for costruisci un'array che contiene le path da analizzare

cmq...mi sa che sta sbagliando ragionamento...ogni path non conterrà altre sotto path? quindi ogni processo figlio dovrà essere in grado di rifare tutta l'analisi

ogni figlio chiama una funzione che analizza l'intero albero di directory... il problema è fargliela chiamare solo sui path che gli competono.. cmq ci rifletto dopo.. per ora sto facendo tutto con un processo per sistemare le altre cosette

[}gu|do[z]{®©]

ho risolto così:
(ora vedete una stampa.. giusto per debuggare.. poi ci metterò la chiamata alla funzione che elaborerà quell'albero di directory

        //temporaneo: legge il numero di path e di processi da linea di comando. Comodo per il debug
        num_path = atoi(argv[2]);
	num_proc = atoi(argv[3]);

	if(num_path < num_proc) num_proc = num_path; //se il numero di processi è in eccesso.. utilizzo quelli che mi  servono

	int per_proc = num_path/num_proc; //calcolo quanti path deve elaborare ogni processo
	int ultimo = per_proc + (num_path%num_proc); //calcolo quanti path deve elaborare l'ultimo processo
	printf("Ogni processo deve analizzare %d paths\nl'ultimo processo deve analizzarne %d\n",per_proc,ultimo);

	int i,t,j;
	pid_t pid;
	//genero figli: un'iterazione per ogni processo
	//ma mi incremento anche t che mi indica da che path deve partire il processo che viene gerato.
        //Lo incremento esattamente di per_proc 
	for(i=1,t=1; i<=num_proc; i++,t=t+per_proc)	
	 {
	    switch(pid = fork())
            {
              case -1: //errore della fork
                perror("Fork");
                exit(-1);

              case 0: //sezione del figlio

		  if(i==num_proc)//ultimo processo: esplora tutti i path rimasti..
		    {
			 printf("Ultimo processo\n");
			 for(j=t;j<t+ultimo;j++) //parte da t ed elabora tanti path quanti ne deve elaborare l'ultimo processo
				 printf("%d\n",j); //da sostituire con l'elaborazione del j-esimo path del buffer
		    }
		  else //processo generico: esplora esattamente "per_path" paths
		    {
			 printf("Processo %d\n",i);
			 for(j=t;j<t+per_proc;j++) //dal mio inizio t, per per_proc paths
				printf("%d\n",j); //da sostituire con l'elaborazione del j-esimo path del buffer
		    }
                  exit(0);

               default: //sezione del padre: continua solo il ciclo
                continue;
           }//fine switch
	}//fine for

funge

ma se è migliorabile come stile...
ci tengo a far bella figura

[kentaromiura]

ben fatto..
..i commenti allineali tutti lungo lo stesso asse y a destra aggiungendoci dei tab