Vcluster_log.hpp

/*
 * Vcluster_log.hpp
 *
 *  Created on: Jul 11, 2015
 *      Author: Pietro Incardona
 */

#ifndef VCLUSTER_LOG_HPP_
#define VCLUSTER_LOG_HPP_

#include <fstream>
#include "timer.hpp"

#ifdef VERBOSE_TEST

class Vcluster_log
{
    timer t;

    // delay of the log
    size_t log_delay;

    size_t rank;

    // Receive status vector
    openfpm::vector<MPI_Status> r_log;

    // Send processors vector
    openfpm::vector<size_t> s_log;

    // log file
    std::ofstream f;

public:

    void start(size_t log_delay)
    {
        this->log_delay = log_delay;
        t.start();
    }

    void openLog(size_t rank)
    {
        int result;
        char p_name[MPI_MAX_PROCESSOR_NAME];
        MPI_Get_processor_name(p_name, &result );

        std::stringstream str;
        str << "vcluster_log_" << p_name << "_" << rank;
        f.open(str.str());
    }

    void logRecv(MPI_Status & stat)
    {
        r_log.add(stat);
    }

    void logSend(size_t prc)
    {
        s_log.add(prc);
    }

    void NBXreport(size_t nbx, openfpm::vector<MPI_Request> & req, bool reach_b, MPI_Status bar_stat)
    {
        // req and s_log must match

        if (req.size() != s_log.size())
            std::cerr << "Error: " << __FILE__ << ":" << __LINE__ << " req.size() != s_log.size() " << req.size() << "!=" << s_log.size() << "\n" ;

        // if it is waiting more than 20 seconds
        // Write a deadlock status report
        if (t.getwct() >= log_delay)
        {
            f << "=============================== NBX ==================================\n";

            int flag;

            f << "NBX counter: " << nbx << "\n";
            f << "\n";

            // Print the send requests and their status
            for (size_t i = 0 ; i < req.size() ; i++)
            {
                MPI_Status stat;
                MPI_SAFE_CALL(MPI_Request_get_status(req.get(i),&flag,&stat));
                if (flag == true)
                    f << "Send to: " << s_log.get(i) << " with tag " << stat.MPI_TAG << " completed" << "\n";
                else
                    f << "Send to: " << s_log.get(i) << " with tag " << stat.MPI_TAG << " pending" << "\n";
            }

            f << "\n";

            // Print the receive request and their status

            for (size_t j = 0 ; j < r_log.size() ; j++)
            {
                f << "Received from: " << r_log.get(j).MPI_SOURCE << " with tag " << r_log.get(j).MPI_TAG << "\n";
            }

            // Barrier status

            if (reach_b == true)
                f << "Barrier status: active\n";
            else
                f << "Barrier status: inactive\n";



            f << "======================================================================\n";
            f.flush();

            t.reset();
        }
    }

    void clear()
    {
        r_log.clear();
        s_log.clear();
    }
};

#else

class Vcluster_log
{
public:
    inline void start(size_t log_delay) {}
    inline void openLog(size_t rank)    {}
    inline void logRecv(MPI_Status & stat)  {}
    inline void logSend(size_t prc) {}
    inline void NBXreport(size_t nbx, openfpm::vector<MPI_Request> & req, bool reach_b, MPI_Status bar_stat)    {}
    inline void clear() {};
};

#endif



#endif /* VCLUSTER_LOG_HPP_ */