/* ************************************************************************
 * Copyright 2015 Advanced Micro Devices, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * ************************************************************************ */

#pragma once
#ifndef _STATISTICALTIMER_CPU_H_
#define _STATISTICALTIMER_CPU_H_
#include <iosfwd>
#include <vector>
#include <algorithm>
#include "clsparseTimer.hpp"

/**
 * \file clSPARSETimer-host.h
 * \brief A timer class that provides a cross platform timer for use
 * in timing code progress with a high degree of accuracy.
 *	This class is implemented entirely in the header, to facilitate inclusion into multiple
 *	projects without needing to compile an object file for each project.
 */

class clsparseHostTimer: public clsparseTimer
{
    //	Private typedefs
    typedef std::vector< cl_ulong > clkVector;
    typedef	std::pair< std::string, cl_uint > labelPair;
    typedef	std::vector< labelPair > stringVector;

    //	In order to calculate statistics <std. dev.>, we need to keep a history of our timings
    stringVector	labelID;
    clkVector	clkStart;
    std::vector< clkVector >	clkTicks;

    //	How many clockticks in a second
    cl_ulong	clkFrequency;

    //	For linux; the resolution of a high-precision timer
    //  Mingw32 does not define timespec; can use windows timers
#if !defined( _WIN32 )
    timespec res;
#endif

    //	Saved sizes for our vectors, used in Reset() to reallocate vectors
    clkVector::size_type	nEvents, nSamples;

    //	This setting controls whether the Timer should convert samples into time by dividing by the
    //	clock frequency
    bool normalize;

    /**
     * \fn StatisticalTimer()
     * \brief Constructor for StatisticalTimer that initializes the class
     *	This is private so that user code cannot create their own instantiation.  Instead, you
     *	must go through getInstance( ) to get a reference to the class.
     */
    clsparseHostTimer( );

    /**
     * \fn ~StatisticalTimer()
     * \brief Destructor for StatisticalTimer that cleans up the class
     */
    ~clsparseHostTimer( );

    /**
     * \fn StatisticalTimer(const StatisticalTimer& )
     * \brief Copy constructors do not make sense for a singleton, disallow copies
     */
    clsparseHostTimer( const clsparseHostTimer& );

    /**
     * \fn operator=( const StatisticalTimer& )
     * \brief Assignment operator does not make sense for a singleton, disallow assignments
     */
    clsparseHostTimer& operator=( const clsparseHostTimer& );

    friend std::ostream& operator<<( std::ostream& os, const clsparseHostTimer& s );

    /**
     * \fn void AddSample( const size_t id, const cl_ulong n )
     * \brief Explicitely add a timing sample into the class
     */
    void AddSample( const size_t id, const cl_ulong n );

    //	Calculate the average/mean of data for a given event
    cl_double	getMean( size_t id ) const;

    //	Calculate the variance of data for a given event
    //	Variance - average of the squared differences between data points and the mean
    cl_double	getVariance( size_t id ) const;

    //	Sqrt of variance, also in units of the original data
    cl_double	getStdDev( size_t id ) const;

    /**
     * \fn double getAverageTime(size_t id) const
     * \return Return the arithmetic mean of all the samples that have been saved
     */
    cl_double getAverageTime( size_t id ) const;

    /**
     * \fn double getMinimumTime(size_t id) const
     * \return Return the arithmetic min of all the samples that have been saved
     */
    cl_double getMinimumTime( size_t id ) const;

public:
    /**
     * \fn getInstance()
     * \brief This returns a reference to the singleton timer.  Guarantees only 1 timer class is ever
     *	instantiated within a compilable executable.
     */
    static clsparseHostTimer& getInstance( );

    /**
     * \fn void Start( size_t id )
     * \brief Start the timer
     * \sa Stop(), Reset()
     */
    void Start( size_t id );

    /**
     * \fn void Stop( size_t id )
     * \brief Stop the timer
     * \sa Start(), Reset()
     */
    void Stop( size_t id );

    /**
     * \fn void Reset(void)
     * \brief Reset the timer to 0
     * \sa Start(), Stop()
     */
    void Clear( );

    /**
     * \fn void Reset(void)
     * \brief Reset the timer to 0
     * \sa Start(), Stop()
     */
    void Reset( );

    void Reserve( size_t nEvents, size_t nSamples );

    size_t getUniqueID( const std::string& label, cl_uint groupID );

    //	Calculate the average/mean of data for a given event
    void	setNormalize( bool norm );

    void Print( cl_ulong flopCount, std::string unit );

    //	Using the stdDev of the entire population (of an id), eliminate those samples that fall
    //	outside some specified multiple of the stdDev.  This assumes that the population
    //	form a gaussian curve.
    size_t	pruneOutliers( cl_double multiple );
    size_t pruneOutliers( size_t id, cl_double multiple );
};

#endif // _STATISTICALTIMER_CPU_H_
