engine.hpp

Go to the documentation of this file.

 
// Copyright (C) 2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
 
#ifndef _HEBench_API_Bridge_Base_Engine_H_7e5fa8c2415240ea93eff148ed73539b
#define _HEBench_API_Bridge_Base_Engine_H_7e5fa8c2415240ea93eff148ed73539b
 
#include <cstdint>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include "engine_object.hpp"
#include "hebench/api_bridge/types.h"
 
namespace hebench {
namespace cpp {
 
class BaseEngine;
class BenchmarkDescription;
class BaseBenchmark;
 
struct BenchmarkHandle
{
    BaseBenchmark *p_benchmark;
    BenchmarkDescription *p_bench_description;
};
 
BaseEngine *createEngine(const std::int8_t *p_buffer, std::uint64_t size); // implement this
void destroyEngine(BaseEngine *p); // implement this
 
class BaseEngine : public ITaggedObject
{
private:
    HEBERROR_DECLARE_CLASS_NAME(BaseEngine)
 
public:
    BaseEngine(const BaseEngine &) = delete;
    BaseEngine &operator=(const BaseEngine &) = delete;
 
    BaseEngine(BaseEngine &&) = delete;
    BaseEngine &operator=(BaseEngine &&) = delete;
 
public:
    static constexpr std::int64_t tag = 0x8000000000000000; // bit 63
public:
    ~BaseEngine() override {}
 
    std::int64_t classTag() const override { return tag; }
 
    static const std::string &getErrorDesc(hebench::APIBridge::ErrorCode err_code);
    static hebench::APIBridge::ErrorCode getLastError() { return m_last_error; }
    static const std::string &getLastErrorDesc() { return m_s_last_error_description; }
    static void setLastError(hebench::APIBridge::ErrorCode value);
    static void setLastError(hebench::APIBridge::ErrorCode value,
                             const std::string &err_desc);
 
    std::string getBenchmarkDescriptionEx(hebench::APIBridge::Handle h_bench_desc,
                                          const hebench::APIBridge::WorkloadParams *p_w_params) const;
 
    const std::unordered_map<hebench::APIBridge::Scheme, std::string> &
    schemeName() const { return m_map_scheme_name; }
    const std::unordered_map<hebench::APIBridge::Security, std::string> &
    securityName() const { return m_map_security_name; }
 
    std::uint64_t subscribeBenchmarkCount() const { return m_descriptors.size(); }
    void subscribeBenchmarks(hebench::APIBridge::Handle *p_h_bench_descs, std::uint64_t count) const;
    std::uint64_t getWorkloadParamsCount(hebench::APIBridge::Handle h_bench_desc) const;
    std::uint64_t getDefaultWorkloadParamsCount(hebench::APIBridge::Handle h_bench_desc) const;
    void describeBenchmark(hebench::APIBridge::Handle h_bench_desc,
                           hebench::APIBridge::BenchmarkDescriptor *p_bench_desc,
                           hebench::APIBridge::WorkloadParams *p_default_params,
                           std::uint64_t default_count) const;
    hebench::APIBridge::Handle createBenchmark(hebench::APIBridge::Handle h_bench_desc,
                                               const hebench::APIBridge::WorkloadParams *p_params);
    void destroyBenchmark(hebench::APIBridge::Handle h_bench);
 
    template <class T, typename... Args>
    hebench::APIBridge::Handle createHandle(std::uint64_t size, std::int64_t extra_tags,
                                            Args &&... args) const;
    hebench::APIBridge::Handle duplicateHandle(hebench::APIBridge::Handle h, std::int64_t new_tag, std::int64_t check_tags) const;
    hebench::APIBridge::Handle duplicateHandle(hebench::APIBridge::Handle h, std::int64_t check_tags = 0) const;
    template <class T, typename... Args>
    T &retrieveFromHandle(hebench::APIBridge::Handle h, std::int64_t extra_tags = 0) const;
 
    template <class T, typename... Args>
    EngineObject *createEngineObj(Args &&... args) const;
    template <class T, typename... Args>
    std::shared_ptr<T> createRAII(Args &&... args) const;
    template <class T, typename... Args>
    T *createObj(Args &&... args) const;
    template <class T>
    void destroyObj(T *p) const
    {
        if (p)
            delete p;
    }
 
protected:
    BaseEngine();
    virtual void init() = 0;
 
    std::shared_ptr<BenchmarkDescription> matchBenchmark(hebench::APIBridge::Handle h_desc) const;
 
    void addBenchmarkDescription(std::shared_ptr<BenchmarkDescription> p_desc);
    void addSchemeName(hebench::APIBridge::Scheme scheme, const std::string &name);
    void addSecurityName(hebench::APIBridge::Security security, const std::string &name);
    static void addErrorCode(hebench::APIBridge::ErrorCode code, const std::string &description);
 
private:
    void checkHandleTags(hebench::APIBridge::Handle h, std::int64_t check_tags) const;
    hebench::APIBridge::Handle duplicateHandleInternal(hebench::APIBridge::Handle h, std::int64_t new_tag) const;
 
    static const std::string UnknownErrorMsg;
    static hebench::APIBridge::ErrorCode m_last_error;
    static std::string m_s_last_error_description;
    static std::unordered_map<hebench::APIBridge::ErrorCode, std::string> m_map_error_desc;
 
    std::vector<std::shared_ptr<BenchmarkDescription>> m_descriptors;
    std::unordered_map<hebench::APIBridge::Scheme, std::string> m_map_scheme_name;
    std::unordered_map<hebench::APIBridge::Security, std::string> m_map_security_name;
};
 
template <class T, typename... Args>
hebench::APIBridge::Handle BaseEngine::createHandle(std::uint64_t size, std::int64_t extra_tags,
                                                    Args &&... args) const
{
    if ((extra_tags & ITaggedObject::MaskReservedBits) != 0)
        throw hebench::cpp::HEBenchError(HEBERROR_MSG_CLASS("Invalid 'extra_tags' detected. Most significant 8 bits of tags are reserved."),
                                         HEBENCH_ECODE_CRITICAL_ERROR);
 
    hebench::cpp::EngineObject *p_retval = createEngineObj<T>(std::forward<Args>(args)...);
 
    hebench::APIBridge::Handle retval;
    retval.p    = p_retval;
    retval.size = size;
    retval.tag  = p_retval->classTag() | extra_tags;
 
    return retval;
}
 
template <class T, typename... Args>
T &BaseEngine::retrieveFromHandle(hebench::APIBridge::Handle h, std::int64_t extra_tags) const
{
    if ((extra_tags & ITaggedObject::MaskReservedBits) != 0)
        throw hebench::cpp::HEBenchError(HEBERROR_MSG_CLASS("Invalid 'extra_tags' detected. Most significant 8 bits of tags are reserved."),
                                         HEBENCH_ECODE_CRITICAL_ERROR);
    if ((h.tag & hebench::cpp::EngineObject::tag) != hebench::cpp::EngineObject::tag)
        throw hebench::cpp::HEBenchError(HEBERROR_MSG_CLASS("Invalid tag detected. Expected EngineObject::tag."),
                                         HEBENCH_ECODE_CRITICAL_ERROR);
    if ((h.tag & extra_tags) != extra_tags)
        throw hebench::cpp::HEBenchError(HEBERROR_MSG_CLASS("Invalid tag detected. Expected " + std::to_string(extra_tags) + "."),
                                         HEBENCH_ECODE_CRITICAL_ERROR);
 
    if (!h.p)
        throw hebench::cpp::HEBenchError(HEBERROR_MSG_CLASS("Invalid null handle."),
                                         HEBENCH_ECODE_CRITICAL_ERROR);
 
    // retrieve our internal format object from the handle
    hebench::cpp::EngineObject *p_obj = reinterpret_cast<hebench::cpp::EngineObject *>(h.p);
    return p_obj->get<T>();
}
 
template <class T, typename... Args>
EngineObject *BaseEngine::createEngineObj(Args &&... args) const
{
    std::shared_ptr<T> raii = createRAII<T>(std::forward<Args>(args)...);
    EngineObject *retval    = new EngineObject(*this, raii);
    return retval;
}
 
template <class T, typename... Args>
std::shared_ptr<T> BaseEngine::createRAII(Args &&... args) const
{
    std::shared_ptr<T> retval = std::shared_ptr<T>(this->createObj<T>(std::forward<Args>(args)...),
                                                   [this](T *p) {
                                                       this->destroyObj<T>(p);
                                                   });
    return retval;
}
 
template <class T, typename... Args>
T *BaseEngine::createObj(Args &&... args) const
{
    return new T(std::forward<Args>(args)...);
}
 
} // namespace cpp
} // namespace hebench
 
#endif // defined _HEBench_API_Bridge_Base_Engine_H_7e5fa8c2415240ea93eff148ed73539b