GenericEventHandler.hpp

/*

Copyright (C) University of Oxford, 2005-2010

University of Oxford means the Chancellor, Masters and Scholars of the
University of Oxford, having an administrative office at Wellington
Square, Oxford OX1 2JD, UK.

This file is part of Chaste.

Chaste is free software: you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.

Chaste is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
License for more details. The offer of Chaste under the terms of the
License is subject to the License being interpreted in accordance with
English Law and subject to any action against the University of Oxford
being under the jurisdiction of the English Courts.

You should have received a copy of the GNU Lesser General Public License
along with Chaste. If not, see <http://www.gnu.org/licenses/>.

*/


#ifndef GENERICEVENTHANDLER_HPP_
#define GENERICEVENTHANDLER_HPP_

#include <cassert>
#include <ctime>
#include <iostream>

#include "Exception.hpp"
#include "PetscTools.hpp"

template <unsigned NUM_EVENTS, class CONCRETE>
class GenericEventHandler
{
    friend class TestGenericEventHandler;
    friend class TestCellBasedEventHandler;
    friend class TestHeartEventHandler;

private:
    static std::vector<double> mCpuTime; 
    static std::vector<bool> mHasBegun; 
    static bool mEnabled; 
    static bool mInitialised; 
    static bool mInUse; 
    inline static void MilliSleep(unsigned milliseconds)
    {
        double start = clock();
        double min_ticks = milliseconds*(CLOCKS_PER_SEC/1000.0) + start;
        while (clock() < min_ticks)
        {
            //pause;
        }
    }

    inline static double GetCpuTime()
    {
        return clock();
    }

    inline static double ConvertTicksToMilliseconds(double clockTicks)
    {
        return clockTicks/(CLOCKS_PER_SEC/1000.0);
    }

    inline static double ConvertTicksToSeconds(double clockTicks)
    {
        return clockTicks/(CLOCKS_PER_SEC);
    }

    inline static void CheckVectorSizes()
    {
        if (!mInitialised)
        {
            mCpuTime.resize(NUM_EVENTS, 0.0);
            mHasBegun.resize(NUM_EVENTS, false);
            mInitialised = true;
        }
    }

public:

    static void Reset()
    {
        CheckVectorSizes();
        for (unsigned event=0; event<NUM_EVENTS; event++)
        {
            mCpuTime[event] = 0.0;
            mHasBegun[event] = false;
        }
        Enable();
        mInUse=false;
    }

    static void BeginEvent(unsigned event) throw (Exception)
    {
        if (!mEnabled)
        {
            return;
        }
        mInUse = true;
        assert(event<NUM_EVENTS);
        CheckVectorSizes();
        //Check that we are recording the total
        if (event<NUM_EVENTS-1)
        {
            if (!mHasBegun[NUM_EVENTS-1])
            {
                //Silently open the "total" event
                BeginEvent(NUM_EVENTS-1);
            }
        }
        if (mHasBegun[event])
        {
            std::string msg;
            msg += "The event associated with the counter for '";
            msg += CONCRETE::EventName[event];
            msg += "' had already begun when BeginEvent was called.";
            std::cerr << msg << std::endl << std::flush;
            Disable();
            return;
        }
        mCpuTime[event] -= GetCpuTime();
        mHasBegun[event] = true;
        //std::cout << PetscTools::GetMyRank()<<": Beginning " << EVENT_NAME[event] << " @ " << (clock()/1000) << std::endl;
    }

    static void EndEvent(unsigned event)
    {
        assert(event<NUM_EVENTS);
        if (!mEnabled)
        {
            return;
        }
        CheckVectorSizes();
        if (!mHasBegun[event])
        {
            std::string msg;
            msg += "Error: The event associated with the counter for '";
            msg += CONCRETE::EventName[event];
            msg += "' had not begun when EndEvent was called.";
            EXCEPTION(msg);
        }
        mCpuTime[event] += GetCpuTime();
        mHasBegun[event] = false;
        //std::cout << PetscTools::GetMyRank()<<": Ending " << EVENT_NAME[event] << " @ " << (clock()/1000) << std::endl;
    }

    static double GetElapsedTime(unsigned event)
    {
        assert(event<NUM_EVENTS);
        if (!mEnabled)
        {
            return 0.0;
        }
        CheckVectorSizes();
        double ticks;
        if (mHasBegun[event])
        {
            ticks =  mCpuTime[event] + GetCpuTime();
        }
        else
        {
            ticks = mCpuTime[event];
        }
        return ConvertTicksToMilliseconds(ticks);
    }

    static void Report()
    {
        CheckVectorSizes();

        if (!mEnabled)
        {
            EXCEPTION("Asked to report on a disabled event handler.  Check for contributory errors above.");
        }
        if (!mInUse)
        {
            EXCEPTION("Asked to report on an event handler which is set to zero.");
        }
        //Check that all events are finished
        for (unsigned event=0; event<NUM_EVENTS; event++)
        {
            if (mHasBegun[event])
            {
                //Silently close event
                EndEvent(event);
            }
        }
        const unsigned top_event = NUM_EVENTS-1;
        double total = ConvertTicksToSeconds(mCpuTime[top_event]);

        // Make the output precision depend on total run time
        const char* format;
        if (total > 999999.0)      // 11.5 days
        {
            format = "%8.0f ";     // will allow up to 115 days before columns unaligned
        }
        else if (total > 9999.0)   // 2.7 hours
        {
            format = "%8.1f ";
        }
        else
        {
            format = "%8.3f ";
        }

        for (unsigned turn=0; turn<PetscTools::GetNumProcs(); turn++)
        {
            std::cout.flush();
            PetscTools::Barrier();
            if (turn == PetscTools::GetMyRank())
            {
                if (!PetscTools::IsSequential())
                {
                    // Report the process number at the beginning of the line
                    printf("%3i: ", turn); //5 chars
                }
                for (unsigned event=0; event<NUM_EVENTS; event++)
                {
                    const double secs = ConvertTicksToSeconds(mCpuTime[event]);
                    printf(format, secs);
                    printf("(%3.0f%%)  ", total == 0.0 ? 0.0 : (secs/total*100.0));
                }
                std::cout << "(seconds) \n";
            }
        }

        // If there is a collection of processes then report an average
        if (!PetscTools::IsSequential())
        {
            double total_cpu_time[NUM_EVENTS];
            MPI_Reduce(&mCpuTime[0], total_cpu_time, NUM_EVENTS, MPI_DOUBLE,
                       MPI_SUM, 0, PETSC_COMM_WORLD);
            if (PetscTools::AmMaster())
            {
                total = ConvertTicksToSeconds(total_cpu_time[top_event]);
                printf("avg: "); //5 chars
                for (unsigned event=0; event<NUM_EVENTS; event++)
                {
                    const double secs = ConvertTicksToSeconds(total_cpu_time[event]);
                    printf(format, secs/PetscTools::GetNumProcs());
                    printf("(%3.0f%%)  ", total == 0.0 ? 0.0 : (secs/total*100.0));
                }
                std::cout << "(seconds) \n";
            }

            double max_cpu_time[NUM_EVENTS];
            MPI_Reduce(&mCpuTime[0], max_cpu_time, NUM_EVENTS, MPI_DOUBLE,
                       MPI_MAX, 0, PETSC_COMM_WORLD);
            if (PetscTools::AmMaster())
            {
                total = ConvertTicksToSeconds(max_cpu_time[top_event]);
                printf("max: "); //5 chars
                for (unsigned event=0; event<NUM_EVENTS; event++)
                {
                    const double secs = ConvertTicksToSeconds(max_cpu_time[event]);
                    printf(format, secs);
                    printf("(%3.0f%%)  ", total == 0.0 ? 0.0 : (secs/total*100.0));
                }
                std::cout << "(seconds) \n";
            }
        }
        std::cout.flush();
        PetscTools::Barrier();
        std::cout.flush();

        Reset();
    }

    static void Headings()
    {
        CheckVectorSizes();
        // Make sure that all output (on all processes) is flushed
        std::cout.flush();
        PetscTools::Barrier();
        std::cout.flush();
        if (PetscTools::AmMaster())
        {
            if (!PetscTools::IsSequential())
            {
                // Report the process number at the beginning of the line
                printf("Proc "); //5 chars
            }
            for (unsigned event=0; event<NUM_EVENTS; event++)
            {
                printf("%15s%2s", CONCRETE::EventName[event], "");
            }
            std::cout << "\n";
            std::cout.flush();
        }
    }

    static void Enable()
    {
        CheckVectorSizes();
        mEnabled = true;
    }

    static void Disable()
    {
        CheckVectorSizes();
        mEnabled = false;
    }

    static bool IsEnabled()
    {
        return mEnabled;
    }
};

template<unsigned NUM_EVENTS, class CONCRETE>
std::vector<double> GenericEventHandler<NUM_EVENTS, CONCRETE>::mCpuTime;

template<unsigned NUM_EVENTS, class CONCRETE>
std::vector<bool> GenericEventHandler<NUM_EVENTS, CONCRETE>::mHasBegun;

template<unsigned NUM_EVENTS, class CONCRETE>
bool GenericEventHandler<NUM_EVENTS, CONCRETE>::mEnabled = true;

template<unsigned NUM_EVENTS, class CONCRETE>
bool GenericEventHandler<NUM_EVENTS, CONCRETE>::mInitialised = false;

template<unsigned NUM_EVENTS, class CONCRETE>
bool GenericEventHandler<NUM_EVENTS, CONCRETE>::mInUse = false;

#endif /*GENERICEVENTHANDLER_HPP_*/