benchmark.hpp

Go to the documentation of this file.

 
// Copyright (C) 2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
 
#ifndef _HEBench_API_Bridge_Benchmark_H_7e5fa8c2415240ea93eff148ed73539b
#define _HEBench_API_Bridge_Benchmark_H_7e5fa8c2415240ea93eff148ed73539b
 
#include <cstdint>
#include <memory>
#include <vector>
 
#include "engine_object.hpp"
#include "error_handling.hpp"
#include "hebench/api_bridge/types.h"
#include "workload_params.hpp"
 
namespace hebench {
namespace cpp {
 
class BaseEngine;
class BaseBenchmark;
 
class BenchmarkDescription : public ITaggedObject
{
public:
    static constexpr std::int64_t tag = 0x1000000000000000; // bit 60
public:
    BenchmarkDescription()          = default;
    virtual ~BenchmarkDescription() = default;
 
    void getBenchmarkDescriptor(hebench::APIBridge::BenchmarkDescriptor &bench_desc) const;
    const hebench::APIBridge::BenchmarkDescriptor &getBenchmarkDescriptor() const { return m_descriptor; }
    const std::vector<std::vector<hebench::APIBridge::WorkloadParam>> &getWorkloadDefaultParameters() const { return m_default_params; }
    virtual std::string getBenchmarkDescription(const hebench::APIBridge::WorkloadParams *p_w_params) const;
 
    std::size_t getWorkloadParameterCount() const;
    virtual BaseBenchmark *createBenchmark(BaseEngine &engine,
                                           const hebench::APIBridge::WorkloadParams *p_params) = 0;
    virtual void destroyBenchmark(BaseBenchmark *p_bench) = 0;
 
    std::int64_t classTag() const override { return BenchmarkDescription::tag; }
 
protected:
    hebench::APIBridge::BenchmarkDescriptor m_descriptor;
 
    void addDefaultParameters(const WorkloadParams::Common &default_params_set);
    void addDefaultParameters(const std::vector<hebench::APIBridge::WorkloadParam> &default_params_set);
 
private:
    std::vector<std::vector<hebench::APIBridge::WorkloadParam>> m_default_params;
};
 
class BaseBenchmark : public ITaggedObject
{
private:
    HEBERROR_DECLARE_CLASS_NAME(BaseBenchmark)
 
public:
    static constexpr std::int64_t tag = 0x4000000000000000; // bit 62
 
    BaseBenchmark(BaseEngine &engine,
                  const hebench::APIBridge::BenchmarkDescriptor &bench_desc,
                  const hebench::APIBridge::WorkloadParams &bench_params);
    BaseBenchmark(BaseEngine &engine,
                  const hebench::APIBridge::BenchmarkDescriptor &bench_desc);
    virtual ~BaseBenchmark() = default;
 
    virtual void initialize(const hebench::APIBridge::BenchmarkDescriptor &bench_desc_concrete);
    virtual hebench::APIBridge::Handle encode(const hebench::APIBridge::DataPackCollection *p_parameters)          = 0;
    virtual void decode(hebench::APIBridge::Handle encoded_data, hebench::APIBridge::DataPackCollection *p_native) = 0;
    virtual hebench::APIBridge::Handle encrypt(hebench::APIBridge::Handle encoded_data)                            = 0;
    virtual hebench::APIBridge::Handle decrypt(hebench::APIBridge::Handle encrypted_data)                          = 0;
 
    virtual hebench::APIBridge::Handle load(const hebench::APIBridge::Handle *p_local_data, std::uint64_t count)              = 0;
    virtual void store(hebench::APIBridge::Handle remote_data, hebench::APIBridge::Handle *p_local_data, std::uint64_t count) = 0;
 
    virtual hebench::APIBridge::Handle operate(hebench::APIBridge::Handle h_remote_packed,
                                               const hebench::APIBridge::ParameterIndexer *p_param_indexers,
                                               std::uint64_t indexers_count) = 0;
 
    BaseEngine &getEngine() { return m_engine; }
    const BaseEngine &getEngine() const { return m_engine; }
 
    std::int64_t classTag() const override { return BaseBenchmark::tag; }
 
    const hebench::APIBridge::BenchmarkDescriptor &getDescriptor() const { return m_bench_description; }
    const std::vector<hebench::APIBridge::WorkloadParam> &getWorkloadParameters() const { return m_bench_params; }
 
protected:
    static std::uint64_t findDataPackIndex(const hebench::APIBridge::DataPackCollection &parameters,
                                           std::uint64_t param_position);
    static const hebench::APIBridge::DataPack &findDataPack(const hebench::APIBridge::DataPackCollection &parameters,
                                                            std::uint64_t param_position);
    static hebench::APIBridge::DataPack &findDataPack(hebench::APIBridge::DataPackCollection &parameters,
                                                      std::uint64_t param_position);
    void setDescriptor(const hebench::APIBridge::BenchmarkDescriptor &value) { m_bench_description = value; }
 
private:
    BaseEngine &m_engine;
    hebench::APIBridge::BenchmarkDescriptor m_bench_description;
    std::vector<hebench::APIBridge::WorkloadParam> m_bench_params;
};
 
} // namespace cpp
} // namespace hebench
 
#endif // defined _HEBench_API_Bridge_Benchmark_H_7e5fa8c2415240ea93eff148ed73539b