Head to Head

Back to    Contents

Previous :  Roundtrip      Next : Funzioni bloccanti e non bloccanti      Up to : Benchmark punto-punto

Il nucleo della funzione che implementa  il test Head to Head è :

elapsed_time = 0;
if(ctx->is_master){  /*sono il processo master? cioè il mio pid è 0?*/
    recv_from = MPI_ANY_SOURCE;
    if (source_type==SpecifiedSource) recv_from = to;/*to è lo slave, il proc con pid size-1*/
        MPI_Recv(rbuffer,len,MPI_BYTE,recv_from,0,MPI_COMM_WORLD,&status); /*sincronizzazione*/
    t0=MPI_Wtime();
    for(i=0;i<reps;i++){
        MPI_Send(sbuffer,len,MPI_BYTE,to,MSG_TAG(i),MPI_COMM_WORLD);
        MPI_Recv(rbuffer,len,MPI_BYTE,recv_from,MSG_TAG(i),MPI_COMM_WORLD,&status);
    }
    t1 = MPI_Wtime();
    elapsed_time = t1-t0;
}

if(ctx->is_slave){/*sono lo slave?cioè il compagno di master?cioè il proc con pid size-1?*/
    recv_from = MPI_ANY_SOURCE;
    if (source_type == SpecifiedSource) recv_from = to;/to è il master*/
        MPI_Send(sbuffer,len,MPI_BYTE,from,0,MPI_COMM_WORLD);/*sincronizzazione*/
    for(i=0;i<reps;i++){
        MPI_Send(sbuffer,len,MPI_BYTE,to,MSG_TAG(i),MPI_COMM_WORLD);
        MPI_Recv(rbuffer,len,MPI_BYTE,recv_from,MSG_TAG(i),MPI_COMM_WORLD,&status);
    }
}

dove : 

• reps è per default 50 e rappresenta il numero di round che vengono eseguiti.
• ctx è un record che contiene informazioni sui partecipanti al test. Di default saranno il processo con pid 0 e il processo con pid Communicatori_size-1. Quello con pid 0 sarà il master, quello con pid size-1 lo slave.

Come si vede c'è molto più parallelismo di esecuzione rispetto alla Roundtrip. Infatti i Risultati mostreranno come la trasmissione con questo test sia molto più veloce in entrambi i sistemi MPICH e MPICH-G2. La cosa interessante è però che, con questo test, MPICH-G2 risulta più veloce anche rispetto a MPICH se la  dimensione dei pacchetti abbastanza è grande.Nella sezione Conclusioni cercheremo di dare una spiegazione a questo fenomeno. 

L'algoritmo :

1. si eseguono di default 50(reps) Round di ping-pong e si misura il tempo totale t0 - t1,
2. la funzione chiamante divide t0 - t1 per reps, ottenendo il tempo medio per un round,
3. confronta il valore ottenuto con l'accuratezza de clock di sistema :
   •  se risulta almeno 100 volte più grande (cioè l'errore è inferiore all'uno per cento) il test si considera corretto,
   •  altrimenti : il test è già fallito per dieci volte?
     • si  : allora si abortisce il programma,
     • no : si torna al punto 1. incrementando il numero di ripetizioni reps,
4. si aggiunge un elemento ad un'apposita lista, dove ogni nodo rappresenta un test terminato con successo con una diversa dimensione di messaggio.

L'ultima fase è quella si smoothing dove una apposita funzione scorre la lista dei risultati e per ogni nodo calcola una stima del suo valore in base al precedente ed al successivo :

 t_est:=  (t_successivo-t_precedente)/(dim_msg_successivo-dim_msg_precedente)*(dim_msg_attuale-dim_msg_precedente) + t_precedente.

se il risultato del test è sbagliato di oltre il 10% rispetto al tempo stimato si ripete il test di quel particolare nodo.

Previous : Roundtrip       Next :  Funzioni bloccanti e non bloccanti       Up to :  Benchmark Punto-Punto

Back to Contents