LINUX AVANZATO 2007

texino ha scritto:

Doc ha scritto:

Qualcuno che ha fatto la prova di programmanzione il 26 sa dirmi esattamente quanto tempo ha dato?

il tempo base è 1 ora è mezza, ma è molto elastico a seconda di quante persone finiscono la prova.
Il 26 penso che sia arrivato a più di 2 ore poi se proprio nn va il programma... niente da fare.

ti ringrazio, effettivamente mi rassicura; per ora ho iniziato con quello del 27-5-2006 e ho notato che non ero una scheggia nel finire, ma con un'ora e mezza-due penso di starci bene

Valefede ha scritto:

Dirac ha scritto:

Valefede ha scritto:

qualcuno ha provato fare l'esercizio?? io non riesco proprio, non trovo una buona dispensa sull'uso della clone.

Qualcuno ha buone fonti??

trajano.us.es/clases/lcd/man/man2/clone.2.html

Grazie mille, ma ti sfido a fare l'esercizio dato il 26 con queste informazioni!!

Come faccio a sincronizzare i due thread in modo che uno capisca dove è arrivato l'altro???? una variabile?? un file???

Provate a farlo e vedrete che di problemi ne escono un sacco. Così sembra facile....

Tieni gli offset relativi alla posizione di ciascun processo in due interi.. e li confronti.

Nash ha scritto:

Valefede ha scritto:

Dirac ha scritto:

Valefede ha scritto:

qualcuno ha provato fare l'esercizio?? io non riesco proprio, non trovo una buona dispensa sull'uso della clone.

Qualcuno ha buone fonti??

trajano.us.es/clases/lcd/man/man2/clone.2.html

Grazie mille, ma ti sfido a fare l'esercizio dato il 26 con queste informazioni!!

Come faccio a sincronizzare i due thread in modo che uno capisca dove è arrivato l'altro???? una variabile?? un file???

Provate a farlo e vedrete che di problemi ne escono un sacco. Così sembra facile....

Tieni gli offset relativi alla posizione di ciascun processo in due interi.. e li confronti.

Quoto in pieno!!!

l'avevo pensato anche io ma questi due offset devono essere protetti con un lock no?
se io sono A:

1) verifico che il byte che vado a controllare non è incluso nelll'offset di B
2) lo includo nel mio offset
2) vado ad elaborare il byte

tra il punto 1 e 2 l'altro porocesso potrebbe fare lo stesso e quindi lo andiamo a fare 2 volte. Sbaglio qualcosa?

Valefede ha scritto:

l'avevo pensato anche io ma questi due offset devono essere protetti con un lock no?
se io sono A:

1) verifico che il byte che vado a controllare non è incluso nelll'offset di B
2) lo includo nel mio offset
2) vado ad elaborare il byte

tra il punto 1 e 2 l'altro porocesso potrebbe fare lo stesso e quindi lo andiamo a fare 2 volte. Sbaglio qualcosa?

Lo metti in attesa di un segnale che a invia quando ha finito!

Ho provato a scrivere un implementazione usando i lock (descritti nel cosro di sistemi operativi del prof).
Purtoppo non funziona, il primo clone fa una parte del lavoro e poi muore non so perchè mentro il secondo clone mi pare che non parta proprio.
Ora provo a fare con i segnali invece dei lock.

#include<stdio.h>
#include<stdlib.h>
#include<signal.h>
#include<unistd.h>
#include<sched.h>
#include<fcntl.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<sys/mman.h>
#include<errno.h>
#include<sys/wait.h>

char* pa;
int dim_file;
int index_a=0, index_b=0;


int lock(char* p){
int fd, retcode;
while(1){
fd = open(p, O_RDWR|O_CREAT|O_EXCL);
if((fd<0) && (errno == EEXIST)){
retcode = sched_yield();
}
else
{
if(fd < 0){
printf("lock open error %s\n", strerror(errno));
retcode = -1;
break;
}
else
{
retcode=fd;
break;
}
}
}
return retcode;
}

int unlock (char* p, int fd){
int retcode;
retcode = close(fd);
if(retcode < 0){
printf("unlock close error\n");
return retcode;
}
else
{
unlink(p);
return retcode;
}
}

int run_b (void* arg){

//int index_a=0;
//int confronto;
int retlock_a, retlock_b;

while(index_b>0){
printf("b - %d\n", index_b);
retlock_a = lock("a");
retlock_b = lock("b");
if(index_b>index_a){
index_b--;
unlock("a", retlock_a);
unlock("b", retlock_b);
pa[index_b+1]='b';
}
else
{
unlock("a", retlock_a);
unlock("b", retlock_b);
return 5;
}
}
return 9;
}

int run_a (void* arg){

//int index_a=0;
//int confronto;
int retlock_a, retlock_b;
while(index_a<dim_file){
printf("a - %i\n", index_a);
retlock_a = lock("a");
retlock_b = lock("b");
if(index_a<index_b){
index_a++;
unlock("a", retlock_a);
unlock("b", retlock_b);
pa[index_a-1]='a';
}
else
{
unlock("a", retlock_a);
unlock("b", retlock_b);
return 3;
}
//if(index_a>(int)(dim_file/2)){sched_yield();}
}
return 7;
}



int main (int argc, char* argv[]){
int pid[3];
char stack[2][2047];


pid[0] = getpid(); //Pid del processo principale
fprintf(stderr, "Sono il processo principale, il mio pid è %d, nel gruppo %d, il mio processo padre è %d\n", pid[0], getgid(), getppid());

sleep(1); //Fa in modo ch ela shell stampi in ordine

int fd = open("prova.txt", O_RDWR, S_IRWXU);
if (fd<0){printf("Errore in apertura\n"); return 1;}
else {printf("Aperto il file %d\n", fd);}

dim_file = lseek(fd, 0, SEEK_END);
lseek(fd, 0, SEEK_SET);

pa = (char*) mmap(0, dim_file, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
if(pa!=MAP_FAILED){printf("File mappato\n");}
else {printf("Problema nella mappatura\n");}

index_b = dim_file;
printf("Dimensione del file %d\n", index_b);

pid[1] = clone (run_a, &stack[0][2047], CLONE_FILES|CLONE_VM|CLONE_SIGHAND, NULL);
if(pid[1]<0){fprintf(stderr, "Clone 1 fallito\n");}
else{fprintf(stderr, "Il pid del figlio 1 è %d\n", pid[1]);}
sleep(1);

pid[2] = clone (run_b, &stack[0][2047], CLONE_FILES|CLONE_VM|CLONE_SIGHAND, NULL);
if(pid[2]<0){fprintf(stderr, "Clone 2 fallito\n");}
else{fprintf(stderr, "Il pid del figlio 2 è %d\n", pid[2]);}
sleep(1);

int status;
waitpid(pid[1], &status, __WCLONE);
printf("Clone a terminato, %d\n", status);
waitpid(pid[2], &status, __WCLONE);
printf("Clone b terminato\n", status);

/*
int kill_rit = kill(pid[2], SIGTERM);
if(kill_rit<0){fprintf(stderr, "Problema nel kill\n");}
kill_rit = kill(pid[2], SIGTERM);
if(kill_rit<0){fprintf(stderr, "Problema nel kill\n");}
*/

return 0;
}