hebench_benchmark_description.h

Go to the documentation of this file.

 
// Copyright (C) 2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
 
#ifndef _HEBench_Harness_BenchmarkDescription_H_0596d40a3cce4b108a81595c50eb286d
#define _HEBench_Harness_BenchmarkDescription_H_0596d40a3cce4b108a81595c50eb286d
 
#include <cstdint>
#include <cstring>
#include <functional>
#include <memory>
#include <ratio>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "hebench/api_bridge/types.h"
 
namespace hebench {
namespace TestHarness {
 
class Engine;
 
namespace BenchmarkDescription {
 
class Backend
{
private:
    struct Internal
    {
        std::size_t m_index;
        hebench::APIBridge::Handle m_handle;
        hebench::APIBridge::BenchmarkDescriptor m_descriptor;
        std::size_t m_operation_params_count;
    };
    Internal m_backend_description;
 
public:
    friend class hebench::TestHarness::Engine;
 
    const std::size_t &index;
    const hebench::APIBridge::Handle &handle;
    const hebench::APIBridge::BenchmarkDescriptor &descriptor;
    std::size_t &operation_params_count;
 
    Backend() :
        Backend(true)
    {
    }
    Backend(const Backend &src) :
        Backend(false)
    {
        m_backend_description = src.m_backend_description;
    }
    virtual ~Backend() {}
    Backend &operator=(const Backend &src)
    {
        if (&src != this)
        {
            this->m_backend_description = src.m_backend_description;
        } // end if
        return *this;
    }
 
private:
    Backend(bool init) :
        m_backend_description(),
        index(m_backend_description.m_index),
        handle(m_backend_description.m_handle),
        descriptor(m_backend_description.m_descriptor),
        operation_params_count(m_backend_description.m_operation_params_count)
    {
        if (init)
            std::memset(&m_backend_description, 0, sizeof(m_backend_description));
    }
};
 
class Configuration
{
public:
    Configuration() :
        default_min_test_time_ms(0),
        fallback_default_sample_size(0),
        b_single_path_report(false)
    {
    }
 
    std::uint64_t default_min_test_time_ms;
    std::uint64_t fallback_default_sample_size;
    std::string dataset_filename;
    std::vector<std::uint64_t> default_sample_sizes;
    std::vector<hebench::APIBridge::WorkloadParam> w_params;
    bool b_single_path_report;
};
 
class Description
{
public:
    std::int64_t workload;
    std::string workload_name;
    std::string data_type;
    std::string category;
    std::string cipher_flags;
    std::string security;
    std::string scheme;
    std::string other;
    std::string header;
    std::string path;
};
 
} // namespace BenchmarkDescription
} // namespace TestHarness
} // namespace hebench
 
#endif // defined _HEBench_Harness_BenchmarkDescription_H_0596d40a3cce4b108a81595c50eb286d