hayai_test_result.hpp

Go to the documentation of this file.

#ifndef __HAYAI_TESTRESULT
#define __HAYAI_TESTRESULT
#include <vector>
#include <stdexcept>
#include <limits>

#include "hayai/hayai_clock.hpp"


namespace hayai
{

    struct TestResult
    {
    public:

        TestResult(const std::vector<uint64_t>& runTimes,
                   std::size_t iterations)
            :   _runTimes(runTimes),
                _iterations(iterations),
                _timeTotal(0),
                _timeRunMin(std::numeric_limits<uint64_t>::max()),
                _timeRunMax(std::numeric_limits<uint64_t>::min())
        {
            // Summarize under the assumption of values being accessed more
            // than once.
            std::vector<uint64_t>::iterator runIt = _runTimes.begin();

            while (runIt != _runTimes.end())
            {
                const uint64_t run = *runIt;

                _timeTotal += run;

                if ((runIt == _runTimes.begin()) || (run > _timeRunMax))
                {
                    _timeRunMax = run;
                }

                if ((runIt == _runTimes.begin()) || (run < _timeRunMin))
                {
                    _timeRunMin = run;
                }

                ++runIt;
            }
        }


        inline double TimeTotal() const
        {
            return double(_timeTotal);
        }


        inline const std::vector<uint64_t>& RunTimes() const
        {
            return _runTimes;
        }


        inline double RunTimeAverage() const
        {
            return double(_timeTotal) / double(_runTimes.size());
        }


        inline double RunTimeMaximum() const
        {
            return double(_timeRunMax);
        }


        inline double RunTimeMinimum() const
        {
            return double(_timeRunMin);
        }


        inline double RunsPerSecondAverage() const
        {
            return 1000000000.0 / RunTimeAverage();
        }


        inline double RunsPerSecondMaximum() const
        {
            return 1000000000.0 / _timeRunMin;
        }


        inline double RunsPerSecondMinimum() const
        {
            return 1000000000.0 / _timeRunMax;
        }


        inline double IterationTimeAverage() const
        {
            return RunTimeAverage() / double(_iterations);
        }


        inline double IterationTimeMinimum() const
        {
            return _timeRunMin / double(_iterations);
        }


        inline double IterationTimeMaximum() const
        {
            return _timeRunMax / double(_iterations);
        }


        inline double IterationsPerSecondAverage() const
        {
            return 1000000000.0 / IterationTimeAverage();
        }


        inline double IterationsPerSecondMinimum() const
        {
            return 1000000000.0 / IterationTimeMaximum();
        }


        inline double IterationsPerSecondMaximum() const
        {
            return 1000000000.0 / IterationTimeMinimum();
        }
    private:
        std::vector<uint64_t> _runTimes;
        std::size_t _iterations;
        uint64_t _timeTotal;
        uint64_t _timeRunMin;
        uint64_t _timeRunMax;
    };
}
#endif