[semafori] Bouncing balls

Si devono sincronizzare N_BALLS thread “ball” che controllano una pallina su un campo di gioco. Le palline rimbalzano se raggiungono un bordo o se colpiscono un’altra pallina (il rimbalzo è visualizzato con un *).

+------------------------------------------------------------------------------+
|                                                        *                 o   |
|           o            o                             o                       |
|                                                                              |
|                                                                              |
|    o                              o                                          |
|                                              o                               |
|                                                                              |
|                                                                              |
| o                                                                            |
|                                           o                                  |
|                                                                           o  |
|                           o          o                                       |
|                                o                                             |
|                           o                                                  |
|                                  o                                           |
|                              o                                               |
|                                 o                                            |
|                           *            o                                     |
+------------------------------------------------------------------------------+

Le palline devono muoversi tutte assieme secondo un “tick” controllato da un altro thread. I thread “ball” si comportano come segue:

while (1) {
    attendi_tick(id); // attende il prossimo "tick"

    /** calcola la nuova posizione nx,ny **/

    inizia_mossa(nx,ny);

    /***** esegue la mossa sulla board condivisa in posizione nx,ny ****/

    fine_mossa(nx,ny);
}

Il thread “tick” si comporta nel modo seguente:

while(1) {
    /**** attende il prossimo tick ****/

    /*** stampa la board, le palline dovrebbero essersi mosse tutte! ***/

    esegui_tick(); // fa muovere le palline
}

Si devono realizzare le seguenti funzioni di sincronizzazione basate su semafori, in modo da evitare interferenze sull’accesso alla board condivisa e in modo che che le palline attendano il tick prima di muoversi:

/******* PARTE DA CONSEGNARE ********/

// dichiarazione dei semafori qui

void inizializza() {
}

void inizia_mossa(int x, int y) {
}

void fine_mossa(int x, int y) {
}

void attendi_tick(int id) {
}

void esegui_tick() {
}

void chiudi() {
}

/******** FINE PARTE DA CONSEGNARE ********/

Utilizzare il seguente programma di test in grado di rilevare interferenze e errori di sincronizzazione tra palline e tick.

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.