phase_core.h

Go to the documentation of this file.

 
#ifndef CPPBENCHMARK_PHASE_CORE_H
#define CPPBENCHMARK_PHASE_CORE_H
 
#include "benchmark/phase_metrics.h"
#include "benchmark/phase_scope.h"
#include "benchmark/system.h"
 
#include <limits>
#include <mutex>
#include <vector>
 
namespace CppBenchmark {
 
 
class PhaseCore : public Phase
{
    friend class BenchmarkBase;
    friend class Benchmark;
    friend class BenchmarkPC;
    friend class BenchmarkThreads;
    friend class Executor;
    friend class Launcher;
 
public:
 
    explicit PhaseCore(const std::string& name) : _name(name), _thread(System::CurrentThreadId())
    { _metrics_result._total_time = std::numeric_limits<int64_t>::max(); }
    PhaseCore(const PhaseCore&) = delete;
    PhaseCore(PhaseCore&&) = delete;
    virtual ~PhaseCore() = default;
 
    PhaseCore& operator=(const PhaseCore&) = delete;
    PhaseCore& operator=(PhaseCore&&) = delete;
 
    PhaseMetrics& current() { return _metrics_current; }
 
    // Implementation of Phase
    const std::string& name() const noexcept override { return _name; }
    const PhaseMetrics& metrics() const noexcept override { return _metrics_result; }
    std::shared_ptr<Phase> StartPhase(const std::string& phase) override;
    std::shared_ptr<Phase> StartPhaseThreadSafe(const std::string& phase) override;
    void StopPhase() override { StopCollectingMetrics(); }
    std::shared_ptr<PhaseScope> ScopePhase(const std::string& phase) override
    { return std::make_shared<PhaseScope>(StartPhase(phase)); }
    std::shared_ptr<PhaseScope> ScopePhaseThreadSafe(const std::string& phase) override
    { return std::make_shared<PhaseScope>(StartPhaseThreadSafe(phase)); }
 
protected:
    std::mutex _mutex;
    std::string _name;
    uint64_t _thread;
    std::vector<std::shared_ptr<PhaseCore>> _child;
    PhaseMetrics _metrics_current;
    PhaseMetrics _metrics_result;
 
 
    void InitLatencyHistogram(const std::tuple<int64_t, int64_t, int>& latency) noexcept
    { _metrics_current.InitLatencyHistogram(latency); }
 
    void PrintLatencyHistogram(FILE* file, int32_t resolution) const noexcept
    { _metrics_result.PrintLatencyHistogram(file, resolution); }
 
    void StartCollectingMetrics() noexcept
    { _metrics_current.StartCollecting(); }
    void StopCollectingMetrics() noexcept
    { _metrics_current.StopCollecting(); }
 
    void MergeMetrics()
    { _metrics_result.MergeMetrics(_metrics_current); }
    void MergeMetrics(PhaseCore& phase)
    { _metrics_result.MergeMetrics(phase._metrics_result); }
    void ResetMetrics() noexcept
    { _metrics_current.ResetMetrics(); }
};
 
} // namespace CppBenchmark
 
#endif // CPPBENCHMARK_PHASE_CORE_H