Subversion Repositories Games.Chess Giants

/*

    Texel - A UCI chess engine.

    Copyright (C) 2013  Peter Österlund, peterosterlund2@gmail.com

    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.

    This program 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 General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

/*

 * timeUtil.hpp

 *

 *  Created on: Sep 20, 2013

 *      Author: petero

 */

#ifndef TIMEUTIL_HPP_

#define TIMEUTIL_HPP_

#include "util.hpp"

#include <array>

#include <cmath>

#include <cassert>

/** Return current wall clock time in milliseconds, starting at some arbitrary point in time. */

S64 currentTimeMillis();

/** Return current wall clock time in seconds, starting at some arbitrary point in time. */

double currentTime();

/** Class that measures average CPU utilization. */

class UtilizationTimer {

public:

    /** Constructor. All times start at zero. */

    UtilizationTimer();

    /** Reset times to zero. */

    void reset();

    /** Set the current CPU efficiency factor to p.

     * A negative p indicates the CPU is idle. */

    void setPUseful(double p);

    /** Return elapsed time size last reset, the amount of useful time spent,

     * and the amount of time the CPU has been idle. */

    void getStats(double& elapsed, double& useful, double& sleep);

private:

    /** Update tElapsed, tUseful, tSleep and increase t0 to current time. */

    void update();

    double t0;          // Time stand for last update()

    double pUseful;     // Current CPU efficiency factor

    double tElapsed;    // Total elapsed time since reset()

    double tUseful;     // Total spent useful time

    double tSleep;      // total idle time.

};

/** Class that tracks statistics for a set of samples. */

class SampleStatistics {

public:

    /** Constructor. */

    SampleStatistics();

    /** Remove all samples. */

    void reset();

    /** Add a sample. */

    void addSample(double value);

    /** Return number of samples. */

    int numSamples() const;

    /** Return average sample value. */

    double avg() const;

    /** Return standard deviation of samples. */

    double std() const;

    /** Add other to *this. */

    SampleStatistics& operator+=(const SampleStatistics& other);

private:

    int nSamples;

    double sum;

    double sqSum;

};

/** Gather statistics about time samples. */

class TimeSampleStatistics {

public:

    /** Constructor. */

    TimeSampleStatistics();

    /** Start timer. */

    void start();

    /** Stop timer and add elapsed time as a sample. */

    void stop();

    /** Remove all time samples. */

    void reset();

    /** Return true if timer is currently running. */

    bool isStarted() const;

    /** Return number of time samples. */

    int numSamples() const;

    /** Return average sample time. */

    double avg() const;

    /** Return standard deviation of time samples. */

    double std() const;

    /** Print to "os", time values displayed in nanoseconds. */

    void printNs(std::ostream& os) const;

private:

    double t0;

    bool started;

    SampleStatistics stats;

};

/** A fixed size vector of TimeSampleStatistics objects. */

template <int N>

class TimeSampleStatisticsVector {

private:

    std::array<TimeSampleStatistics, N> vec;

public:

    TimeSampleStatistics& operator[](int i);

    using iterator = typename std::array<TimeSampleStatistics, N>::iterator;

    iterator begin();

    iterator end();

};

/** Utility function to add a time sample to a TimeSampleStatistics object.

 * The sample value is equal to the amount of time this object is in scope. */

class ScopedTimeSample {

public:

    ScopedTimeSample(TimeSampleStatistics& tStat);

    ~ScopedTimeSample();

    ScopedTimeSample(ScopedTimeSample&) = delete;

    ScopedTimeSample& operator=(const ScopedTimeSample&) = delete;

private:

    TimeSampleStatistics& timeStat;

};

inline

UtilizationTimer::UtilizationTimer() {

    reset();

}

inline void

UtilizationTimer::reset() {

    t0 = currentTime();

    pUseful = -1;

    tElapsed = 0;

    tUseful = 0;

    tSleep = 0;

}

inline void

UtilizationTimer::setPUseful(double p) {

    update();

    pUseful = p;

}

inline void

UtilizationTimer::getStats(double& elapsed, double& useful, double& sleep) {

    update();

    elapsed = tElapsed;

    useful = tUseful;

    sleep = tSleep;

}

inline void

UtilizationTimer::update() {

    double tNow = currentTime();

    double dt = tNow - t0;

    tElapsed += dt;

    if (pUseful >= 0)

        tUseful += dt * pUseful;

    else

        tSleep += dt;

    t0 = tNow;

}

inline

SampleStatistics::SampleStatistics() {

    reset();

}

inline void

SampleStatistics::reset() {

    nSamples = 0;

    sum = 0.0;

    sqSum = 0.0;

}

inline void

SampleStatistics::addSample(double value) {

    nSamples++;

    sum += value;

    sqSum += value * value;

}

inline int

SampleStatistics::numSamples() const {

    return nSamples;

}

inline double

SampleStatistics::avg() const {

    return nSamples > 0 ? sum / nSamples : 0;

}

inline double

SampleStatistics::std() const {

    if (nSamples < 2)

        return 0;

    return ::sqrt((sqSum - sum*sum / nSamples) / (nSamples - 1));

}

inline void

TimeSampleStatistics::printNs(std::ostream& os) const {

    os << numSamples()

       << ' ' << static_cast<int>(avg() * 1e9)

       << ' ' << static_cast<int>(std() * 1e9);

}

inline

TimeSampleStatistics::TimeSampleStatistics() {

    reset();

}

inline void

TimeSampleStatistics::start() {

    t0 = currentTime();

    started = true;

}

inline void

TimeSampleStatistics::stop() {

    double now = currentTime();

    stats.addSample(now - t0);

    started = false;

}

inline void

TimeSampleStatistics::reset() {

    stats.reset();

    started = false;

}

inline bool

TimeSampleStatistics::isStarted() const {

    return started;

}

inline int

TimeSampleStatistics::numSamples() const {

    return stats.numSamples();

}

inline double

TimeSampleStatistics::avg() const {

    return stats.avg();

}

inline double

TimeSampleStatistics::std() const {

    return stats.std();

}

template <int N>

inline TimeSampleStatistics&

TimeSampleStatisticsVector<N>::operator[](int i) {

    return vec[i];

}

template <int N>

inline typename TimeSampleStatisticsVector<N>::iterator

TimeSampleStatisticsVector<N>::begin() {

    return vec.begin();

}

template <int N>

inline typename TimeSampleStatisticsVector<N>::iterator

TimeSampleStatisticsVector<N>::end() {

    return vec.end();

}

inline

ScopedTimeSample::ScopedTimeSample(TimeSampleStatistics& tStat)

  : timeStat(tStat) {

    assert(!timeStat.isStarted());

    timeStat.start();

}

inline

ScopedTimeSample::~ScopedTimeSample() {

    assert(timeStat.isStarted());

    timeStat.stop();

}

#endif /* TIMEUTIL_HPP_ */