hebench_ibenchmark.h

Go to the documentation of this file.

 
// Copyright (C) 2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
 
#ifndef _HEBench_Harness_IBenchmark_H_0596d40a3cce4b108a81595c50eb286d
#define _HEBench_Harness_IBenchmark_H_0596d40a3cce4b108a81595c50eb286d
 
#include <memory>
#include <string>
#include <unordered_set>
#include <vector>
 
#include "hebench/modules/general/include/nocopy.h"
#include "hebench/modules/logging/include/logging.h"
 
#include "hebench/api_bridge/types.h"
#include "hebench_benchmark_description.h"
#include "hebench_idata_loader.h"
#include "hebench_utilities_harness.h"
 
namespace hebench {
namespace TestHarness {
 
class Engine;
class IBenchmark;
class PartialBenchmark;
 
class IBenchmarkDescriptor
{
public:
    DISABLE_COPY(IBenchmarkDescriptor)
    DISABLE_MOVE(IBenchmarkDescriptor)
 
public:
    class DescriptionToken
    {
    public:
        class FriendKeyCreation
        {
        public:
            friend class IBenchmarkDescriptor;
 
        private:
            FriendKeyCreation() {}
        };
        typedef std::shared_ptr<DescriptionToken> Ptr;
 
    public:
        DescriptionToken(IBenchmarkDescriptor &caller,
                         const BenchmarkDescription::Backend &backend_desc,
                         const BenchmarkDescription::Configuration &config,
                         const BenchmarkDescription::Description &text_desc,
                         const FriendKeyCreation &) :
            m_p_caller(&caller),
            m_backend_desc(backend_desc), m_config(config), m_description(text_desc)
        {
        }
 
        IBenchmarkDescriptor *getDescriptor() { return m_p_caller; }
        const BenchmarkDescription::Backend &getBackendDescription() const { return m_backend_desc; }
        const BenchmarkDescription::Configuration &getBenchmarkConfiguration() const { return m_config; }
        const BenchmarkDescription::Description &getDescription() const { return m_description; }
 
    private:
        IBenchmarkDescriptor *m_p_caller;
        BenchmarkDescription::Backend m_backend_desc;
        BenchmarkDescription::Configuration m_config;
        BenchmarkDescription::Description m_description;
    };
 
public:
    IBenchmarkDescriptor()          = default;
    virtual ~IBenchmarkDescriptor() = default;
 
    virtual DescriptionToken::Ptr matchDescriptor(const Engine &engine,
                                                  const BenchmarkDescription::Backend &backend_desc,
                                                  const BenchmarkDescription::Configuration &config) const = 0;
 
    virtual PartialBenchmark *createBenchmark(std::shared_ptr<Engine> p_engine,
                                              const DescriptionToken &description_token) = 0;
    virtual void destroyBenchmark(PartialBenchmark *p_bench) = 0;
 
protected:
    DescriptionToken::Ptr createToken(const BenchmarkDescription::Backend &backend_desc,
                                      const BenchmarkDescription::Configuration &config,
                                      const BenchmarkDescription::Description &text_desc) const;
 
private:
    DescriptionToken::FriendKeyCreation m_key_creation;
};
 
class PartialBenchmarkDescriptor : public IBenchmarkDescriptor
{
public:
    DISABLE_COPY(PartialBenchmarkDescriptor)
    DISABLE_MOVE(PartialBenchmarkDescriptor)
private:
    IL_DECLARE_CLASS_NAME(PartialBenchmarkDescriptor)
 
public:
    static bool getForceConfigValues() { return m_b_force_config_value; }
    static void setForceConfigValues(bool value) { m_b_force_config_value = value; }
 
    static std::uint64_t computeSampleSizes(std::uint64_t *sample_sizes,
                                            std::size_t param_count,
                                            const std::vector<std::uint64_t> &config_sample_sizes,
                                            const hebench::APIBridge::BenchmarkDescriptor &bench_desc,
                                            std::uint64_t default_sample_size_fallback,
                                            bool force_config);
 
public:
    PartialBenchmarkDescriptor();
    ~PartialBenchmarkDescriptor() override;
 
    DescriptionToken::Ptr matchDescriptor(const Engine &engine,
                                          const BenchmarkDescription::Backend &backend_desc,
                                          const BenchmarkDescription::Configuration &config) const override final;
 
protected:
    static std::unordered_set<std::size_t> getCipherParamPositions(std::uint32_t cipher_param_mask);
    static std::string getCategoryName(hebench::APIBridge::Category category);
    static std::string getDataTypeName(hebench::APIBridge::DataType data_type);
 
protected:
    struct WorkloadDescriptionOutput
    {
        std::size_t operation_params_count;
        hebench::APIBridge::BenchmarkDescriptor concrete_descriptor;
        std::string workload_base_name;
        std::string workload_name;
        std::string workload_header;
    };
 
    virtual bool matchBenchmarkDescriptor(const hebench::APIBridge::BenchmarkDescriptor &bench_desc,
                                          const std::vector<hebench::APIBridge::WorkloadParam> &w_params) const = 0;
 
    virtual void completeWorkloadDescription(WorkloadDescriptionOutput &output,
                                             const Engine &engine,
                                             const BenchmarkDescription::Backend &backend_desc,
                                             const BenchmarkDescription::Configuration &config) const = 0;
 
    static void completeCategoryParams(hebench::APIBridge::BenchmarkDescriptor &out_descriptor,
                                       const hebench::APIBridge::BenchmarkDescriptor &in_descriptor,
                                       const BenchmarkDescription::Configuration &config,
                                       bool force_config);
 
private:
    static bool m_b_force_config_value;
 
    void describe(BenchmarkDescription::Backend &concrete_backend_desc,
                  BenchmarkDescription::Configuration &concrete_config,
                  BenchmarkDescription::Description &text_desc,
                  const Engine &engine,
                  const BenchmarkDescription::Backend &backend_desc,
                  const BenchmarkDescription::Configuration &config) const;
};
 
class IBenchmark
{
public:
    DISABLE_COPY(IBenchmark)
    DISABLE_MOVE(IBenchmark)
private:
    IL_DECLARE_CLASS_NAME(IBenchmark)
 
public:
    typedef std::shared_ptr<IBenchmark> Ptr;
    struct RunConfig
    {
        bool b_validate_results;
    };
 
    virtual ~IBenchmark() = default;
 
    virtual bool run(hebench::Utilities::TimingReportEx &out_report, RunConfig &config) = 0;
 
    virtual std::weak_ptr<Engine> getEngine() const          = 0;
    virtual const hebench::APIBridge::Handle &handle() const = 0;
 
protected:
    IBenchmark() = default;
};
 
class PartialBenchmark : public IBenchmark
{
public:
    DISABLE_COPY(PartialBenchmark)
    DISABLE_MOVE(PartialBenchmark)
private:
    IL_DECLARE_CLASS_NAME(PartialBenchmark)
 
public:
    class FriendPrivateKey
    {
        friend class BenchmarkFactory;
 
    private:
        FriendPrivateKey() {}
    };
 
public:
    typedef std::shared_ptr<PartialBenchmark> Ptr;
 
    ~PartialBenchmark() override;
 
    std::weak_ptr<Engine> getEngine() const override { return m_p_engine; }
    const hebench::APIBridge::Handle &handle() const override { return m_handle; }
    virtual std::uint32_t getEventIDStart() const { return 0; }
    std::uint32_t getEventIDNext()
    {
        if (m_b_constructed && m_current_event_id < getEventIDStart())
            m_current_event_id = getEventIDStart();
        return ++m_current_event_id;
    }
 
    virtual void init() = 0;
    void initBackend(hebench::Utilities::TimingReportEx &out_report, const FriendPrivateKey &);
 
    virtual void postInit();
 
    void checkInitializationState(const FriendPrivateKey &) const;
 
protected:
    const BenchmarkDescription::Backend &getBackendDescription() const { return m_backend_desc; }
    const BenchmarkDescription::Configuration &getBenchmarkConfiguration() const { return m_config; }
    const BenchmarkDescription::Description &getDescription() const { return m_text_description; }
 
    PartialBenchmark(std::shared_ptr<Engine> p_engine,
                     const IBenchmarkDescriptor::DescriptionToken &description_token);
 
    void validateRetCode(hebench::APIBridge::ErrorCode err_code, bool last_error = true) const;
 
private:
    void internalInit(const IBenchmarkDescriptor::DescriptionToken &description_token);
 
    std::shared_ptr<Engine> m_p_engine;
    hebench::APIBridge::Handle m_handle;
    BenchmarkDescription::Backend m_backend_desc;
    BenchmarkDescription::Configuration m_config;
    BenchmarkDescription::Description m_text_description;
    std::uint32_t m_current_event_id;
    bool m_b_constructed;
    bool m_b_initialized;
};
 
} // namespace TestHarness
} // namespace hebench
 
#endif // defined _HEBench_Harness_IBenchmark_H_0596d40a3cce4b108a81595c50eb286d