Presentazione  di alcuni concetti di I/O parallelo. In particolare abbiamo scritto e letto un file in modo non contiguo usando un datatype appositamente creato.
#define BUFSIZ 12
#define INTS_PER_BLK 3 
int main(int argc, char* argv[])
{
int my_id, numprocs,length;
int sendb[BUFSIZ],receiveb[BUFSIZ];
MPI_Status status;
MPI_File ilfile;
MPI_Datatype filetype;
[...];
MPI_File_open(com,"Test",MPI_MODE_CREATE|MPI_MODE_RDWR,MPI_INFO_NULL, &ilfile);
// Quante righe 4, di quanti interi 3 , di quanto spaziate 3*numprocs
MPI_Type_vector(BUFSIZ/INTS_PER_BLK,INTS_PER_BLK,INTS_PER_BLK*numprocs,MPI_INT,&filetype);

for (int i=0;i<BUFSIZ;i++) sendb[i]=i+1000*my_id;
MPI_File_set_view(ilfile,INTS_PER_BLK*my_id*sizeof(int),MPI_INT,filetype,"native",MPI_INFO_NULL);
MPI_File_write_all(ilfile,sendb,BUFSIZ,MPI_INT,&status);
MPI_Barrier(com);
Notare come settando una view diversa il file venga letto in modo sequenziale.

MPI_File_set_view(ilfile,BUFSIZ*my_id*sizeof(int),MPI_INT,MPI_INT,"native",MPI_INFO_NULL);
MPI_File_read_all(ilfile,receiveb,BUFSIZ,MPI_INT,&status);I file con i programmi presentati sono scaricabili:Programma 1.
Programma 2.

In queste lezioni abbiamo approfondito il tema della divisione dei dati per affrontare il problema del Game of Life.
Abbiamo inoltre trattato le comunicazioni ASINCRONE in MPI.
Le funzioni Isend e Irecv istanziano un send e un receive non bloccanti. Prima di poter usare di nuovo il buffer di invio o poter leggere il i dati nel buffer di ricezione bisogna verificare che le operazioni siano andate a buon fine tramite le chiamate a MPI_Test, MPI_Wait, MPI_Waitall, MPI_Probe o MPI_Iprobe.

int flag;

MPI_Isend(&sendb,1,MPI_INT,dest,tag,MPI_COMM_WORLD,&request[1]);
MPI_Irecv(&receiveb,1,MPI_INT,dest,tag,com,&request[0]);
MPI_Test(&request[0],&flag,&status[0]);

{ int cc=0;
while(!flag)
{
cout << "aspetto il receive e lavoro "<< cc++ << endl; 
MPI_Test(&request[0],&flag,&status[0]);
}}
cout << "L'esecuzione prosegue dopo i send e receive non bloccanti" << endl;
/* MPI_Wait è una chiamata BLOCCANTE 
che in questo caso attende il completamento del SEND in alternativa Waitall attende TUTTE le richieste di comunicazione contenute nel vettore.*/

MPI_Wait(&request[1],&status[1]);
//MPI_Waitall(2,&request[0],&status[0]); 

Se invece che usare il semplice Test o Wait volessimo avere informazioni più dettagliate su una comunicazione in arrivo dovremmo usare MPI_Probe (Bloccante) o MPI_Iprobe (non bloccante).

//MPI_Probe(MPI_ANY_SOURCE,tag,MPI_COMM_WORLD,&status[0]); BLOCCANTE 
MPI_Iprobe(MPI_ANY_SOURCE,tag,MPI_COMM_WORLD,&flag,&status[0]);

{ int cc=0;
while(!flag)
{
cout << "aspetto il receive e lavoro "<< cc++ << endl; 
MPI_Iprobe(MPI_ANY_SOURCE,tag,MPI_COMM_WORLD,&flag,&status[0]);
}}
// con Get_count ottengo informazioni su quanti elementi ha il messaggio
MPI_Get_count(&status[0],MPI_INT,&count);
// Posso allocare il buffer di receive in base a questo e ricevere il messaggio
    receiveb =(int*)malloc(count*sizeof(int));
MPI_Recv(receiveb,count,MPI_INT,status[0].MPI_SOURCE,tag,MPI_COMM_WORLD,&status[1]);

Le informazioni riguardo al tag ( MPI_TAG ), alla sorgente (MPI_SOUCE), ed errore ( MPI_ERROR )   del messaggio possono essere ottenute dalla struttura MPI_status. Altre informazioni possono essere introdotte in questa struttura dalle implementazioni ma sono fuori dallo standard.

Ancora MPI. Abbiamo illustrato il send bufferizzato (orribile parolaccia ! trovatemi qualcosa di meglio in Italiano !)Prima si riserva il buffer:
int bsiz=(1+MPI_BSEND_OVERHEAD)*sizeof(int);
int buffer[1+MPI_BSEND_OVERHEAD];
Poi lo si aggancia a MPI e lo si usa:
MPI_Buffer_attach(&buffer,bsiz);     
 
switch (my_id)  
{ case 0:  dest=1; break; case 1:  dest=0; break; }
MPI_Bsend(&sendb,1,MPI_INT,dest,tag,MPI_COMM_WORLD); MPI_Recv(&receiveb,1,MPI_INT,dest,tag,com,&status);Alla fine lo si rilascia: MPI_Buffer_detach(&buffer,&bsiz); 


Inoltre abbiamo presentato la funzione sendrecv che permette di accorpare in una singola chiamata sincrona quindi bloccante le operazioni di send e receive. In questo modo il programma viene semplificato in:
switch (my_id)  { case 0:dest=1; break;case 1:dest=0;break;}
MPI_Sendrecv(&sendb,1,MPI_INT,dest,tag,&receiveb,1,MPI_INT,dest,tag,com,&status);

Fino a questo punto abbiamo trattato di messaggi che contengono solo dati contigui in memoria ma se volessimo trasmettere p.es. una colonna di una matrice di un vettore da un processo a un altro non rientriamo più in questo caso. 
MPI risolve questo problema permettendoci di definire nuovi TIPI di dati.  Il caso più semplice è quello di dati non contigui ma equispazitati e si risolve usanto la chiamata MPI_Type_vector. 
Se nel precedente programma i buffer di  send e receive divengono delle matrici:
int sendb[10][10],receiveb[10][10];
Con le righe:
MPI_Datatype colonna;
MPI_Type_vector(10,1,10,MPI_INT,&colonna);
MPI_Type_commit(&colonna);
definisco il nuovo tipo di dato "colonna" fatto di 10 elementi di 1 MPI_INT spaziati in memoria di 10*sizeof(MPI_INT) che poi può essere usato nelle operazioni di scambio di messaggi. Per Esempio:
MPI_Sendrecv(&sendb[0][0],1,colonna,dest,tag,&sendb[0][9],1,colonna,dest,tag,com,&status);

Notate nella riga di esempio la diversa origine e destinazione. In pratica ogno processo invia la colonna 0 nella colonna 9 dell'altro.
Siamo ora pronti per affrontare il metodo più diffuso per lo scambio di dati fra processi, quello delle ghost cells.

I file sorgente degli esempi discussi in questa lezione:
Esempio Bsend
Esempio Sendrecv . E Sendreceive replace.
Esempio di scambio di vettori colonna.