workload_params.hpp

Go to the documentation of this file.

 
// Copyright (C) 2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
 
#ifndef _HEBench_API_Bridge_WorkloadParamsCPP_H_7e5fa8c2415240ea93eff148ed73539b
#define _HEBench_API_Bridge_WorkloadParamsCPP_H_7e5fa8c2415240ea93eff148ed73539b
 
#include <stdexcept>
#include <string>
#include <vector>
 
#include "hebench/api_bridge/types.h"
#include "utilities.hpp"
 
namespace hebench {
namespace cpp {
namespace WorkloadParams {
 
class Common
{
public:
    Common(std::size_t num_params = 0) :
        m_w_params(num_params)
    {
    }
    Common(const std::vector<hebench::APIBridge::WorkloadParam> &w_params) :
        m_w_params(w_params)
    {
    }
    Common(const hebench::APIBridge::WorkloadParams &w_params) :
        m_w_params(w_params.params, w_params.params + w_params.count)
    {
    }
    virtual ~Common() = default;
 
    template <typename T>
    void add(const T &value, const std::string &name = std::string());
    template <typename T>
    void set(std::size_t index, const T &value, const std::string &name);
    template <typename T>
    void set(std::size_t index, const T &value);
    template <typename T>
    const T &get(std::size_t index) const;
    const char *getName(std::size_t index) const { return getParams().at(index).name; }
 
    const std::vector<hebench::APIBridge::WorkloadParam> &getParams() const { return m_w_params; }
 
protected:
    std::vector<hebench::APIBridge::WorkloadParam> m_w_params;
};
 
//-------------------------------------------------------
// class WorkloadParams::Generic template specialization
//-------------------------------------------------------
 
// Int64
 
template <>
inline void Common::add<std::int64_t>(const std::int64_t &value, const std::string &name)
{
    m_w_params.push_back(hebench::APIBridge::WorkloadParam());
    hebench::APIBridge::WorkloadParam &w_param = m_w_params.back();
 
    w_param.data_type = hebench::APIBridge::WorkloadParamType::Int64;
    w_param.i_param   = value;
    Utilities::copyString(w_param.name, HEBENCH_MAX_BUFFER_SIZE, name);
}
 
template <>
inline void Common::set<std::int64_t>(std::size_t index, const std::int64_t &value, const std::string &name)
{
    hebench::APIBridge::WorkloadParam &w_param = m_w_params.at(index);
 
    w_param.data_type = hebench::APIBridge::WorkloadParamType::Int64;
    w_param.i_param   = value;
    Utilities::copyString(w_param.name, HEBENCH_MAX_BUFFER_SIZE, name);
}
 
template <>
inline void Common::set<std::int64_t>(std::size_t index, const std::int64_t &value)
{
    hebench::APIBridge::WorkloadParam &w_param = m_w_params.at(index);
 
    w_param.data_type = hebench::APIBridge::WorkloadParamType::Int64;
    w_param.i_param   = value;
}
 
template <>
inline const std::int64_t &Common::get<std::int64_t>(std::size_t index) const
{
    return m_w_params.at(index).i_param;
}
 
// UInt64
 
template <>
inline void Common::add<std::uint64_t>(const std::uint64_t &value, const std::string &name)
{
    m_w_params.push_back(hebench::APIBridge::WorkloadParam());
    hebench::APIBridge::WorkloadParam &w_param = m_w_params.back();
 
    w_param.data_type = hebench::APIBridge::WorkloadParamType::UInt64;
    w_param.u_param   = value;
    Utilities::copyString(w_param.name, HEBENCH_MAX_BUFFER_SIZE, name);
}
 
template <>
inline void Common::set<std::uint64_t>(std::size_t index, const std::uint64_t &value, const std::string &name)
{
    hebench::APIBridge::WorkloadParam &w_param = m_w_params.at(index);
 
    w_param.data_type = hebench::APIBridge::WorkloadParamType::UInt64;
    w_param.u_param   = value;
    Utilities::copyString(w_param.name, HEBENCH_MAX_BUFFER_SIZE, name);
}
 
template <>
inline void Common::set<std::uint64_t>(std::size_t index, const std::uint64_t &value)
{
    hebench::APIBridge::WorkloadParam &w_param = m_w_params.at(index);
 
    w_param.data_type = hebench::APIBridge::WorkloadParamType::UInt64;
    w_param.u_param   = value;
}
 
template <>
inline const std::uint64_t &Common::get<std::uint64_t>(std::size_t index) const
{
    return m_w_params.at(index).u_param;
}
 
// Float64
 
template <>
inline void Common::add<double>(const double &value, const std::string &name)
{
    m_w_params.push_back(hebench::APIBridge::WorkloadParam());
    hebench::APIBridge::WorkloadParam &w_param = m_w_params.back();
 
    w_param.data_type = hebench::APIBridge::WorkloadParamType::Float64;
    w_param.f_param   = value;
    Utilities::copyString(w_param.name, HEBENCH_MAX_BUFFER_SIZE, name);
}
 
template <>
inline void Common::set<double>(std::size_t index, const double &value, const std::string &name)
{
    hebench::APIBridge::WorkloadParam &w_param = m_w_params.at(index);
 
    w_param.data_type = hebench::APIBridge::WorkloadParamType::Float64;
    w_param.f_param   = value;
    Utilities::copyString(w_param.name, HEBENCH_MAX_BUFFER_SIZE, name);
}
 
template <>
inline void Common::set<double>(std::size_t index, const double &value)
{
    hebench::APIBridge::WorkloadParam &w_param = m_w_params.at(index);
 
    w_param.data_type = hebench::APIBridge::WorkloadParamType::Float64;
    w_param.f_param   = value;
}
 
template <>
inline const double &Common::get<double>(std::size_t index) const
{
    return m_w_params.at(index).f_param;
}
 
//-------------------------------------------
// Workload parameter specialization classes
//-------------------------------------------
 
class MatrixMultiply : public Common
{
public:
    enum : std::size_t
    {
        Index_RowsM0,
        Index_ColsM0,
        Index_ColsM1,
        MinRequiredParameters
    };
 
    std::uint64_t rows_M0() const { return get<std::uint64_t>(Index_RowsM0); }
    std::uint64_t &rows_M0() { return m_w_params.at(Index_RowsM0).u_param; }
    std::uint64_t cols_M0() const { return get<std::uint64_t>(Index_ColsM0); }
    std::uint64_t &cols_M0() { return m_w_params.at(Index_ColsM0).u_param; }
    std::uint64_t cols_M1() const { return get<std::uint64_t>(Index_ColsM1); }
    std::uint64_t &cols_M1() { return m_w_params.at(Index_ColsM1).u_param; }
 
public:
    MatrixMultiply(std::uint64_t _rows_M0 = 0, std::uint64_t _cols_M0 = 0, std::uint64_t _cols_M1 = 0) :
        Common(MinRequiredParameters)
    {
        this->set<std::uint64_t>(Index_RowsM0, _rows_M0, "rows_M0");
        this->set<std::uint64_t>(Index_ColsM0, _cols_M0, "cols_M0");
        this->set<std::uint64_t>(Index_ColsM1, _cols_M1, "cols_M1");
    }
 
    MatrixMultiply(const std::vector<hebench::APIBridge::WorkloadParam> &w_params) :
        Common(w_params)
    {
        validateParams();
    }
    MatrixMultiply(const hebench::APIBridge::WorkloadParams &w_params) :
        Common(w_params)
    {
        validateParams();
    }
 
private:
    void validateParams() const
    {
        if (m_w_params.size() < MinRequiredParameters)
            throw std::out_of_range("Workload requires, at least, " + std::to_string(MinRequiredParameters) + " parameters.");
        for (std::size_t i = 0; i < MinRequiredParameters; ++i)
            if (m_w_params[i].data_type != hebench::APIBridge::WorkloadParamType::UInt64)
                throw std::logic_error("Data type for workload parameter " + std::to_string(i) + " must be WorkloadParamType::UInt64.");
    }
};
 
class VectorSize : public Common
{
public:
    enum : std::size_t
    {
        Index_N,
        MinRequiredParameters
    };
 
    std::uint64_t n() const { return get<std::uint64_t>(Index_N); }
    std::uint64_t &n() { return m_w_params.at(Index_N).u_param; }
 
public:
    VectorSize(std::uint64_t _n = 0) :
        Common(MinRequiredParameters)
    {
        this->set<std::uint64_t>(Index_N, _n, "n");
    }
 
    VectorSize(const std::vector<hebench::APIBridge::WorkloadParam> &w_params) :
        Common(w_params)
    {
        validateParams();
    }
 
    VectorSize(const hebench::APIBridge::WorkloadParams &w_params) :
        Common(w_params)
    {
        validateParams();
    }
 
private:
    void validateParams() const
    {
        if (m_w_params.size() < MinRequiredParameters)
            throw std::out_of_range("Workload requires, at least, " + std::to_string(MinRequiredParameters) + " parameters.");
        for (std::size_t i = 0; i < MinRequiredParameters; ++i)
            if (m_w_params[i].data_type != hebench::APIBridge::WorkloadParamType::UInt64)
                throw std::logic_error("Data type for workload parameter " + std::to_string(i) + " must be WorkloadParamType::UInt64.");
    }
};
 
class Generic : public Common
{
public:
    enum : std::size_t
    {
        Index_N,
        Index_M,
    };
 
    const std::uint64_t &n() const { return get<std::uint64_t>(Index_N); }
    const std::uint64_t &m() const { return get<std::uint64_t>(Index_M); }
    std::uint64_t length_InputParam(std::size_t index) const
    {
        if (index > n())
            throw std::out_of_range(std::string(__func__) + ": Index out of range; "
                                    + std::to_string(index) + ", expected less than " + std::to_string(n()) + ".");
        return get<std::uint64_t>(index + 2);
    }
    std::uint64_t &length_InputParam(std::size_t index)
    {
        if (index >= n())
            throw std::out_of_range(std::string(__func__) + ": Index out of range; "
                                    + std::to_string(index) + ", expected less than " + std::to_string(n()) + ".");
        return m_w_params.at(index + 2).u_param;
    }
    std::uint64_t length_ResultComponent(std::size_t index) const
    {
        if (index >= m())
            throw std::out_of_range(std::string(__func__) + ": Index out of range; "
                                    + std::to_string(index) + ", expected less than " + std::to_string(m()) + ".");
        return get<std::uint64_t>(index + n() + 2);
    }
    std::uint64_t &length_ResultComponent(std::size_t index)
    {
        if (index >= m())
            throw std::out_of_range(std::string(__func__) + ": Index out of range; "
                                    + std::to_string(index) + ", expected less than " + std::to_string(m()) + ".");
        return m_w_params.at(index + n() + 2).u_param;
    }
 
public:
    Generic(std::uint64_t _n = 1, std::uint64_t _m = 1) :
        Common(_n + _m + 2)
    {
        this->set<std::uint64_t>(Index_N, _n, "n");
        this->set<std::uint64_t>(Index_M, _m, "m");
        for (std::size_t i = 0; i < _n; ++i)
            set<std::uint64_t>(2 + i, 1, "length_InputParam" + std::to_string(i));
        for (std::size_t i = 0; i < _m; ++i)
            set<std::uint64_t>(2 + _n + i, 1, "length_ResultComponent" + std::to_string(i));
    }
 
    Generic(const std::vector<hebench::APIBridge::WorkloadParam> &w_params) :
        Common(w_params)
    {
        validateParams();
    }
 
    Generic(const hebench::APIBridge::WorkloadParams &w_params) :
        Common(w_params)
    {
        validateParams();
    }
 
private:
    void validateParams() const
    {
        const std::size_t MinRequiredParameters = n() + m() + 2;
        if (m_w_params.size() < MinRequiredParameters)
            throw std::out_of_range("Workload requires, at least, " + std::to_string(MinRequiredParameters) + " parameters.");
        for (std::size_t i = 0; i < MinRequiredParameters; ++i)
            if (m_w_params[i].data_type != hebench::APIBridge::WorkloadParamType::UInt64)
                throw std::logic_error("Data type for workload parameter " + std::to_string(i) + " must be WorkloadParamType::UInt64.");
    }
};
 
class SimpleSetIntersection : public Common
{
public:
    enum : std::size_t
    {
        Index_N,
        Index_M,
        Index_K,
        MinRequiredParameters
    };
 
    std::uint64_t n() const { return get<std::uint64_t>(Index_N); }
    std::uint64_t &n() { return m_w_params.at(Index_N).u_param; }
    std::uint64_t m() const { return get<std::uint64_t>(Index_M); }
    std::uint64_t &m() { return m_w_params.at(Index_M).u_param; }
    std::uint64_t k() const { return get<std::uint64_t>(Index_K); }
    std::uint64_t &k() { return m_w_params.at(Index_K).u_param; }
 
public:
    SimpleSetIntersection(std::uint64_t _n = 0, std::uint64_t _m = 0, std::uint64_t _k = 1) :
        Common(MinRequiredParameters)
    {
        this->set<std::uint64_t>(Index_N, _n, "n");
        this->set<std::uint64_t>(Index_M, _m, "m");
        this->set<std::uint64_t>(Index_K, _k, "k");
    }
 
    SimpleSetIntersection(const std::vector<hebench::APIBridge::WorkloadParam> &w_params) :
        Common(w_params)
    {
        validateParams();
    }
    SimpleSetIntersection(const hebench::APIBridge::WorkloadParams &w_params) :
        Common(w_params)
    {
        validateParams();
    }
 
private:
    void validateParams() const
    {
        if (m_w_params.size() < MinRequiredParameters)
            throw std::out_of_range("Workload requires, at least, " + std::to_string(MinRequiredParameters) + " parameters.");
        for (std::size_t i = 0; i < MinRequiredParameters; ++i)
            if (m_w_params[i].data_type != hebench::APIBridge::WorkloadParamType::UInt64)
                throw std::logic_error("Data type for workload parameter " + std::to_string(i) + " must be WorkloadParamType::UInt64.");
    }
};
 
typedef VectorSize EltwiseAdd;
typedef VectorSize EltwiseMultiply;
typedef VectorSize DotProduct;
typedef VectorSize LogisticRegression;
 
} // namespace WorkloadParams
} // namespace cpp
} // namespace hebench
 
#endif // defined _HEBench_API_Bridge_WorkloadParamsCPP_H_7e5fa8c2415240ea93eff148ed73539b