[IPC System V] Comunicazione tra processi

[mr_simo]

Ciao a tutti !! Sto facendo un esercizio di inter process comunication e ho dei dubbi per quanto riguarda la comunicazione.
Il testo dell'esercizio è il seguente:

Si trovi una soluzione al problema del banditore utilizzando i meccanismi di IPC System V.

Il banditore comunica che vuole vendere un oggetto ad N partecipanti.

Una volta ricevuta la comunicazione, ogni partecipante sceglie una cifra, una volta scelta la comunica al banditore.

Il banditore attende le offerte, una volta ricevute valuta quella più alta.

Infine comunica a tutti i partecipanti il pid e l'offerta del vincitore.

NB: La comunicazione tra banditore e partecipanti deve avvenire utilizzando o delle code di
messaggi o delle memorie condivise. Tuttavia la comunicazione con almeno uno dei partecipanti
deve avvenire solo tramite code di messaggi e la comunicazione con almeno un altro dei
partecipanti deve avvenire solo tramite memoria condivisa.

Dopo aver creato tutti i file (in C) che mi servono, sono arrivato alla parte comunicativa tra partecipanti e banditore, ed è qui che trovo delle difficoltà.
Ovvero: come faccio a far si che il banditore, in contemporanea trovi l'offerta massima nelle memorie condivise e nella coda di messaggi e poi invii il pid e l'offerta vincente a tutti i partecipanti??

[mr_simo]

qui sotto posto i codici dei file partecipants.c e banditore.c
partecipanti:

Codice: Seleziona tutto

void makeOffer1(pid_t pid);
void makeOffer2(pid_t pid);
void makeOffer3(pid_t pid);

int main(){
  
    int n = PARTECIPANTS;
    int wait_player = 0; // per attendere che termini il player (processo figlio)
    int wait_parent = 0; // per attendere che il padre termini
    int wait_end = 0;

    for(int j=0; j<n; j++){
        pid_t player;
        player = fork();
        if(player < 0){
            printf("Error on %d child creation, %s\n", j+1, strerror(errno));
            exit(-1);
        }
        if(player == 0){ // processo figlio (il partecipante)
            if(j == 0)
                makeOffer3(player);
            else if(j == 1)
                makeOffer1(player);
            else
                makeOffer2(player);

            if(wait_player)
                sleep(wait_player);
            printf("Child %d parent %d exiting\n", j, getppid());
            exit(0);
        }
        else{ //processo padre
            printf("Spawned %d child, pid %d\n", j+1, player); 
            if(wait_parent)
                sleep(wait_parent);
            printf("Go to next child\n");   
       
        }
        

    }
 
    if(wait_end)
        sleep(wait_end);
  
    return 0;

}


void makeOffer1(pid_t pid){

     int read = semget(SEM_READ,1,0);
     if(read < 0){
         printf("semget for semaphore read failed!");
         exit(-1)
     }

     int wright = semget(SEM_WRIGHT,1,0);
     if(wright < 0){
         printf("semget for semaphore wright failed!");
         exit(-1)
     }

     int answer = semget(SEM_ANSWER,1,0);
     if(answer < 0){
         printf("semget for semaphore answer failed!");
         exit(-1)
     }
     
     int mutex_box2 = semget(MUTEX_BOXTWO,1,0);
     if(mutex_box2 < 0){
         printf("semget for semaphore mutex_box2 failed!");
         exit(-1);
     }

    int box_2 = shmget(SHARED_MEMORY1, sizeof(int), 0);
    if(box_2 < 0){
        perror("shmget SHARED_MEMORY1: "); 
        exit(-1);
    }
    int *ptr_box2 = (int *)shmat(box_2,NULL,0);
    if(ptr_box2 < 0){
        perror("shmat shared memory 2 (for a single partecipant): ");
        exit(-1);
    }

    int offer = offerGenerator();
    int pid_tmp = getpid(pid);
    
    waitSem(mutex_box2);
    ptr_box2[0] = offer;
    ptr_box2[1] = pid_tmp;
    signalSem(wright);
    waitSem(read);
    signalSem(mutex_box2);
    waitSem(answer);
}


void makeOffer2(pid_t pid){

     //  allaccio con i semafori
     int read = semget(SEM_READ,1,0);
     if(read < 0){
         printf("semget for semaphore read failed!");
         exit(-1)
     }

     int wright = semget(SEM_WRIGHT,1,0);
     if(wright < 0){
         printf("semget for semaphore wright failed!");
         exit(-1)
     }

     int answer = semget(SEM_ANSWER,1,0);
     if(answer < 0){
         printf("semget for semaphore answer failed!");
         exit(-1)
     }
    
     int mutex_box1 = semget(MUTEX_BOXONE,1,0);
     if(mutex_box1 < 0){
         printf("semget for semaphore mutex_box1 failed!");
         exit(-1);
     }
     
    int box_1 = shmget(SHARED_MEMORY, 8*sizeof(int), 0);
    if(box_1 < 0){
        perror("shmget SHARED_MEMORY: ");
        exit(-1);
    }
    int *ptr_box1 = (int *)shmat(box_1,NULL,0);
    if(ptr_box1 < 0){
        perror("shmat shared memory: ");
        exit(-1);
    }
 
  
    int offer = offerGenerator();
    int pid_tmp = getpid(pid);
 
    waitSem(mutex_box1);
    ptr_box1[0] = offer;
    ptr_box1[1] = pid_tmp;
    signalSem(wright);
    waitSem(read);
    signalSem(mutex_box1);
    waitSem(answer);
}

void makeOffer3(pid_t pid){
    /* coda di messaggi */
    int msg_queue = createQueue(QUEUE_MSG);
    if(msg_queue < 0){
        printf("Error creation queue is failed!!");
        exit(-1);
    }
  
    int offer = offerGenerator();
    int pid_tmp = getpid(pid);
 
    /* invio del messaggio */
    message *msg = malloc(sizeof(message)); 
    msg->msgdata[0] = offer;
    msg->msgdata[1] = pid_tmp;
    wrightMsg(msg_queue, msg,msg->msgdata[0],msg->msgdata[1]);  
   
    /* ricezione del messaggio */ 
    msgWin *msg_winner = malloc(sizeof(msgWin)); 
    receiveMsg(msg_queue, msg_winner);

}
   

banditore:

Codice: Seleziona tutto

void sell();
int main(){

    int wait_bandit = 0;
    int wait_parent = 0;
    int wait_end = 0;

    pid_t bandit;
    bandit = fork();
    
    if(bandit < 0){
        printf("Errore nella creazione del processo banditore!\n");
        exit(-1);
    }
    if(bandit == 0){ //processo figlio
        printf("Banditore pronto per l'esecuzione\n", getppid());
        //sell();
        
        if(wait_bandit)
            sleep(wait_bandit);
        exit(0);
    }
    else{ // processo padre
        printf("Generato processo banditore\n", bandit);
        if(wait_parent)
            sleep(wait_parent);
    }

    if(wait_end)
        sleep(wait_end);
    
    return 0;
}


void sell(){
   
    printf("***********************\n");   
    printf("OGGI VENDO UN OGGETTO!!\n");
    printf("***********************\n");
    printf("L'ASTA PUO' COMINCIARE!!");

    /*allaccio con le memorie condivise */

    /* attacco con la memoria condivisa SHARED_MEMORY per gli N-2 partecipanti */
    int box1 = shmget(SHARED_MEMORY, 8*sizeof(int), 0666);
    if(box1 < 0){
        perror("shmget SHARED_MEMORY: ");
        wait(NULL);
        exit(-1);
    }
    int *ptr_box1 = (int *)shmat(box1,NULL,0666);
    if(ptr_box1 < 0){
        perror("shmat shared memory: ");
        wait(NULL);
        exit(-1);
    }

    /* attacco con la memoria condivisa SHARED_MEMORY1 per il partecipante "privilegiato" */
    int box2 = shmget(SHARED_MEMORY1, sizeof(int), 0666);
    if(box2 < 0){
        perror("shmget SHARED_MEMORY1: ");
        wait(NULL);
        exit(-1);
    }
    int *ptr_box2 = (int *)shmat(box2,NULL,0666);
    if(ptr_box2 < 0){
        perror("shmat shared memory: ");
        wait(NULL);
        exit(-1);
    }
  
    /* attacco con la coda di messaggi */
    int queue = createQueue(QUEUE_MSG);
    if(queue < 0){
        perror("ERROR queue: ");
        exit(-1);
    }
    
    /* attacco i semafori */
    int read = semget(SEM_READ,1,0666);
    if(read < 0){
        perror("Error semget: ");
        wait(NULL);
        exit(-1);
    }
   
    int wright = semget(SEM_WRIGHT,1,0666);
    if(wright < 0){
        perror("Error semget: ");
        wait(NULL);
        exit(-1);
    }
    
    int answer = semget(SEM_ANSWER,1,0666);
    if(answer < 0){
        perror("Error semget: ");
        wait(NULL);
        exit(-1);
    }
  
    int mutex_box1 = semget(MUTEX_BOXONE,1,0666);
    if(mutex_box1 < 0){
        perror("Error semget: ");
        wait(NULL);
        exit(-1);
    }
    
    int mutex_box2 = semget(MUTEX_BOXTWO,1,0666);
    if(mutex_box2 < 0){
        perror("Error semget: ");
        wait(NULL);
        exit(-1);
    }
   
    /* GESTIONE DELLA COMUNICAZIONE */
    int n = PARTECIPANTS-2;
    int position = 0;
    int offer[n];
    int pid[n];
    int winner_off;
    int winner_pid = getpid();

    /* Comunicazione con gli N-2 partecipanti */
    signalSem(mutex_box1);
    waitSem(wright);
    position = searchMaxOffer(offer, n);
    ptr_box1[0]= offer[position];
    ptr_box1[1]= pid[position];
   
    




}