207 lines
4.6 KiB
C++
207 lines
4.6 KiB
C++
///
|
|
/// \author John Farrier
|
|
///
|
|
/// \copyright Copyright 2015, 2016, 2017, 2018. 2019 John Farrier
|
|
///
|
|
/// 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.
|
|
///
|
|
|
|
#include <celero/Benchmark.h>
|
|
#include <celero/Experiment.h>
|
|
#include <celero/ExperimentResult.h>
|
|
#include <celero/PimplImpl.h>
|
|
#include <celero/Statistics.h>
|
|
#include <celero/Timer.h>
|
|
#include <celero/UserDefinedMeasurementCollector.h>
|
|
#include <celero/Utilities.h>
|
|
#include <algorithm>
|
|
#include <cassert>
|
|
|
|
using namespace celero;
|
|
|
|
class ExperimentResult::Impl
|
|
{
|
|
public:
|
|
Impl()
|
|
{
|
|
}
|
|
|
|
explicit Impl(Experiment* const p) : parent(p)
|
|
{
|
|
}
|
|
|
|
/// Track statistics related to execution time about this specific experiment.
|
|
Statistics<int64_t> statsTime;
|
|
Statistics<int64_t> statsRAM;
|
|
|
|
std::shared_ptr<UserDefinedMeasurementCollector> udmCollector;
|
|
|
|
int64_t problemSpaceValue{0};
|
|
double problemSpaceValueScale{1.0};
|
|
uint64_t problemSpaceIterations{0};
|
|
|
|
/// A pointer back to our owning Experiment parent.
|
|
Experiment* parent{nullptr};
|
|
|
|
/// A "completed" flag.
|
|
bool complete{false};
|
|
|
|
/// A "failure" flag.
|
|
bool failure{false};
|
|
};
|
|
|
|
ExperimentResult::ExperimentResult()
|
|
{
|
|
}
|
|
|
|
ExperimentResult::ExperimentResult(Experiment* x) : pimpl(x)
|
|
{
|
|
}
|
|
|
|
ExperimentResult::~ExperimentResult()
|
|
{
|
|
}
|
|
|
|
Experiment* ExperimentResult::getExperiment() const
|
|
{
|
|
return this->pimpl->parent;
|
|
}
|
|
|
|
void ExperimentResult::setProblemSpaceValue(int64_t x, double scale, uint64_t iterations)
|
|
{
|
|
this->pimpl->problemSpaceValue = x;
|
|
this->pimpl->problemSpaceValueScale = scale;
|
|
this->pimpl->problemSpaceIterations = iterations;
|
|
}
|
|
|
|
int64_t ExperimentResult::getProblemSpaceValue() const
|
|
{
|
|
return this->pimpl->problemSpaceValue;
|
|
}
|
|
|
|
double ExperimentResult::getProblemSpaceValueScale() const
|
|
{
|
|
return this->pimpl->problemSpaceValueScale;
|
|
}
|
|
|
|
uint64_t ExperimentResult::getProblemSpaceIterations() const
|
|
{
|
|
return this->pimpl->problemSpaceIterations;
|
|
}
|
|
|
|
Statistics<int64_t>* ExperimentResult::getTimeStatistics()
|
|
{
|
|
return &this->pimpl->statsTime;
|
|
}
|
|
|
|
void ExperimentResult::addRunTimeSample(const uint64_t runTime)
|
|
{
|
|
this->pimpl->statsTime.addSample(runTime);
|
|
}
|
|
|
|
uint64_t ExperimentResult::getRunTime() const
|
|
{
|
|
return this->pimpl->statsTime.getMin();
|
|
}
|
|
|
|
double ExperimentResult::getUsPerCall() const
|
|
{
|
|
if(this->pimpl->failure == false)
|
|
{
|
|
return static_cast<double>(this->pimpl->statsTime.getMin()) / static_cast<double>(this->pimpl->problemSpaceIterations);
|
|
}
|
|
|
|
return 0.0;
|
|
}
|
|
|
|
double ExperimentResult::getCallsPerSecond() const
|
|
{
|
|
if(this->pimpl->failure == false)
|
|
{
|
|
return 1.0 / (this->getUsPerCall() * celero::UsToSec);
|
|
}
|
|
|
|
return 0.0;
|
|
}
|
|
|
|
double ExperimentResult::getUnitsPerSecond() const
|
|
{
|
|
return (this->pimpl->problemSpaceValueScale > 0.0)
|
|
? ((this->pimpl->problemSpaceValue * this->pimpl->problemSpaceIterations / this->pimpl->problemSpaceValueScale)
|
|
/ (this->pimpl->statsTime.getMin() * celero::UsToSec))
|
|
: 0.0;
|
|
}
|
|
|
|
double ExperimentResult::getBaselineMeasurement() const
|
|
{
|
|
if(this->pimpl->parent->getIsBaselineCase() == false)
|
|
{
|
|
const auto bm = this->pimpl->parent->getBenchmark();
|
|
|
|
if(bm != nullptr)
|
|
{
|
|
const auto baselineExperiment = bm->getBaseline();
|
|
|
|
if(baselineExperiment != nullptr)
|
|
{
|
|
const auto baselineResult = baselineExperiment->getResultByValue(this->getProblemSpaceValue());
|
|
|
|
if(baselineResult != nullptr)
|
|
{
|
|
const auto baselineResultUs = baselineResult->getUsPerCall();
|
|
|
|
// Prevent possible divide by zero.
|
|
if(baselineResultUs > 0)
|
|
{
|
|
return this->getUsPerCall() / baselineResult->getUsPerCall();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return -1.0;
|
|
}
|
|
|
|
return 1.0;
|
|
}
|
|
|
|
void ExperimentResult::setComplete(bool x)
|
|
{
|
|
this->pimpl->complete = x;
|
|
}
|
|
|
|
bool ExperimentResult::getComplete() const
|
|
{
|
|
return this->pimpl->complete;
|
|
}
|
|
|
|
void ExperimentResult::setFailure(bool x)
|
|
{
|
|
this->pimpl->failure = x;
|
|
}
|
|
|
|
bool ExperimentResult::getFailure() const
|
|
{
|
|
return this->pimpl->failure;
|
|
}
|
|
|
|
void ExperimentResult::setUserDefinedMeasurements(std::shared_ptr<UserDefinedMeasurementCollector> x)
|
|
{
|
|
this->pimpl->udmCollector = x;
|
|
}
|
|
|
|
std::shared_ptr<UserDefinedMeasurementCollector> ExperimentResult::getUserDefinedMeasurements() const
|
|
{
|
|
return this->pimpl->udmCollector;
|
|
}
|