models/hierarchical/hockney_p2p_model.hpp

#ifndef _HOCKNEY_P2P_MODEL_HPP
#define _HOCKNEY_P2P_MODEL_HPP

#include <boost/serialization/access.hpp>
#include <gsl/gsl_fit.h>

class hockney_p2p_model {
private:
    friend class boost::serialization::access;
    double alpha;
    double beta;

public:
    hockney_p2p_model(double _alpha, double _beta) : alpha(_alpha), beta(_beta) {}
    hockney_p2p_model() : alpha(0.), beta(0.) {}

    template <class Archive> void serialize(Archive & ar, const unsigned int version) {
        ar & alpha;
        ar & beta;
    }

    void estimate(MPI_Comm comm, MPIB_msgset msgset, MPIB_precision precision, int i, int j) {
        int rank;
        MPI_Comm_rank(comm, &rank);
        if ((rank == i) || (rank == j)) {
            int count = 0;
            double* M = NULL ;
            double* T = NULL;
            MPIB_result result;
            int m;
            //calculate the number of iterations for different message sizes
            count = (msgset.max_size - msgset.min_size)/msgset.stride;
            if ((msgset.max_size - msgset.min_size) % msgset.stride > 0 ) count++ ;

            //Only process i in pair (i,j) keeps track of the benchmarks
            if (rank == i) {
                M = (double *) malloc ( count * sizeof(double) );
                T = (double *) malloc ( count * sizeof(double) );
            }
            count = 0;
            for (m = msgset.min_size; m < msgset.max_size; m += msgset.stride) {
                MPIB_measure_p2p(MPI_Send, MPI_Recv, comm, i, j, m, precision, &result);
                if (rank == i) {
                    M[count] = m;
                    //Divide by 2 since we have a Sendrecv container
                    T[count] = result.T / 2.;
                }
                count++;
            }
            if (rank == i) {
                double cov00, cov01, cov11, sumsq;
                gsl_fit_linear(M, 1, T, 1, count, &alpha, &beta, &cov00, &cov01, &cov11, &sumsq);
                free(M);
                free(T);
            }
        }           
    }

    void write_header(ostream &os){
        os << "#p2p:\ta\t\tb\n";
    }
    void write_elem(int i, int j, ostream &os) {
        os << "#" << i <<"-" << j <<":\t" << alpha << "\t" << beta << "\n";
    }
    void write_footer(ostream &os) {
    }
};

#endif /*_HOCKNEY_P2P_MODEL_HPP */