types.h

Go to the documentation of this file.

 
// Copyright (C) 2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
 
#ifndef _HEBench_API_Bridge_Types_H_7e5fa8c2415240ea93eff148ed73539b
#define _HEBench_API_Bridge_Types_H_7e5fa8c2415240ea93eff148ed73539b
 
#include <cstdint>
 
#include "version.h"
 
namespace hebench {
namespace APIBridge {
 
//================
// Error handling
//================
 
typedef std::int32_t ErrorCode;
 
// Predefined error codes
 
#define HEBENCH_ECODE_SUCCESS 0
 
#define HEBENCH_ECODE_INVALID_ARGS 0x7ffffffe
 
 
#define HEBENCH_ECODE_CRITICAL_ERROR 0x7fffffff
 
//===============
// Miscellaneous
//===============
 
#define HEBENCH_MAX_BUFFER_SIZE 256
 
//=======================
// Benchmark descriptors
//=======================
 
#define HEBENCH_MAX_OP_PARAMS 32
#define HEBENCH_MAX_CATEGORY_PARAMS HEBENCH_MAX_OP_PARAMS * 2
 
// Sugested common scheme types
#define HEBENCH_HE_SCHEME_CKKS 100
#define HEBENCH_HE_SCHEME_BFV  101
#define HEBENCH_HE_SCHEME_BGV  102
 
// common flags for parameter combinations
 
#define HEBENCH_HE_PARAM_FLAGS_ALL_CIPHER 0xffffffff
#define HEBENCH_HE_PARAM_FLAGS_ALL_PLAIN  0x0
 
enum Workload
{
    MatrixMultiply = 1,
    EltwiseAdd,
    EltwiseMultiply,
    DotProduct,
    LogisticRegression,
    LogisticRegression_PolyD3,
    LogisticRegression_PolyD5,
    LogisticRegression_PolyD7,
    SimpleSetIntersection,
    Generic
};
 
namespace WorkloadParamType {
 
enum WorkloadParamType
{
    Int64 = 1, 
    UInt64, 
    Float64 
};
 
} // namespace WorkloadParamType
 
struct WorkloadParam
{
    WorkloadParamType::WorkloadParamType data_type;
    char name[HEBENCH_MAX_BUFFER_SIZE];
    union
    {
        int64_t i_param;
        uint64_t u_param;
        double f_param;
    };
};
 
struct WorkloadParams
{
    WorkloadParam *params;
    std::uint64_t count;
};
 
enum DataType
{
    Int32 = 1, 
    Int64, 
    Float32, 
    Float64 
};
 
enum Category
{
    Latency = 1,
    Offline
};
 
typedef std::int32_t Scheme;
typedef std::int32_t Security;
 
struct CategoryParams
{
    std::uint64_t min_test_time_ms;
    union
    {
        std::uint64_t reserved[HEBENCH_MAX_CATEGORY_PARAMS];
        struct
        {
            std::uint64_t warmup_iterations_count;
        } latency; 
        struct
        {
            std::uint64_t data_count[HEBENCH_MAX_OP_PARAMS];
        } offline; 
    };
};
 
struct BenchmarkDescriptor
{
    // benchmark specification
    Workload workload; 
    DataType data_type; 
    Category category; 
    CategoryParams cat_params; 
    std::uint32_t cipher_param_mask; 
    // extra description
    Scheme scheme; 
    Security security; 
    std::int64_t other; 
};
 
//================================
// Data movement and organization
//================================
 
struct _FlexibleData
{
 
    void *p;
 
    std::uint64_t size;
 
    std::int64_t tag;
};
 
#define NULL_HANDLE hebench::APIBridge::_FlexibleData({ 0, 0, 0 })
 
typedef _FlexibleData NativeDataBuffer;
typedef _FlexibleData Handle;
 
struct DataPack
{
    NativeDataBuffer *p_buffers; 
    std::uint64_t buffer_count; 
    std::uint64_t param_position; 
};
 
struct DataPackCollection
{
    DataPack *p_data_packs; 
    std::uint64_t pack_count; 
};
 
struct ParameterIndexer
{
    std::uint64_t value_index; 
    std::uint64_t batch_size; 
};
 
} // namespace APIBridge
} // namespace hebench
 
#endif // defined _HEBench_API_Bridge_Types_H_7e5fa8c2415240ea93eff148ed73539b