hebench_idata_loader.h

Go to the documentation of this file.

 
// Copyright (C) 2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
 
#ifndef _HEBench_Harness_IDataLoader_H_0596d40a3cce4b108a81595c50eb286d
#define _HEBench_Harness_IDataLoader_H_0596d40a3cce4b108a81595c50eb286d
 
#include <memory>
#include <string>
#include <vector>
 
#include "hebench/modules/general/include/nocopy.h"
#include "hebench/modules/logging/include/logging.h"
 
#include "hebench/api_bridge/types.h"
#include "hebench_types_harness.h"
 
namespace hebench {
namespace TestHarness {
 
class IDataLoader
{
public:
    DISABLE_COPY(IDataLoader)
    DISABLE_MOVE(IDataLoader)
private:
    IL_DECLARE_CLASS_NAME(IDataLoader)
 
public:
    template <typename T>
    using unique_ptr_custom_deleter = hebench::TestHarness::unique_ptr_custom_deleter<T>;
 
    struct ResultData
    {
        std::vector<const hebench::APIBridge::NativeDataBuffer *> result;
        std::uint64_t sample_index;
        std::shared_ptr<void> reserved0; // use for RAII if needed
    };
    typedef std::shared_ptr<ResultData> ResultDataPtr;
 
    typedef std::shared_ptr<IDataLoader> Ptr;
 
    virtual ~IDataLoader() {}
 
    static std::size_t sizeOf(hebench::APIBridge::DataType data_type);
 
    static unique_ptr_custom_deleter<hebench::APIBridge::DataPackCollection>
    createDataPackCollection(std::uint64_t data_pack_count);
    static unique_ptr_custom_deleter<hebench::APIBridge::DataPack>
    createDataPack(std::uint64_t buffer_count, std::uint64_t param_position);
    static unique_ptr_custom_deleter<hebench::APIBridge::NativeDataBuffer>
    createDataBuffer(std::uint64_t size, std::int64_t tag);
 
    virtual std::uint64_t getParameterCount() const = 0;
    virtual const hebench::APIBridge::DataPack &getParameterData(std::uint64_t param_position) const = 0;
    virtual std::uint64_t getResultCount() const = 0;
    virtual const hebench::APIBridge::DataPack &getResultData(std::uint64_t param_position) const = 0;
 
    virtual ResultDataPtr getResultFor(const std::uint64_t *param_data_pack_indices) = 0;
    virtual std::uint64_t getResultIndex(const std::uint64_t *param_data_pack_indices) const = 0;
 
    virtual std::uint64_t getTotalDataLoaded() const = 0;
 
protected:
    IDataLoader() {}
};
 
class PartialDataLoader : public IDataLoader
{
public:
    DISABLE_COPY(PartialDataLoader)
    DISABLE_MOVE(PartialDataLoader)
private:
    IL_DECLARE_CLASS_NAME(PartialDataLoader)
 
    template <typename>
    friend class PartialDataLoaderHelper;
 
public:
    typedef std::shared_ptr<PartialDataLoader> Ptr;
 
    ~PartialDataLoader() override {}
 
    std::uint64_t getParameterCount() const override { return m_input_data.size(); }
    const hebench::APIBridge::DataPack &getParameterData(std::uint64_t param_position) const override;
    std::uint64_t getResultCount() const override { return m_output_data.size(); }
    const hebench::APIBridge::DataPack &getResultData(std::uint64_t param_position) const override;
    ResultDataPtr getResultFor(const std::uint64_t *param_data_pack_indices) override;
    std::uint64_t getResultIndex(const std::uint64_t *param_data_pack_indices) const override;
    std::uint64_t getTotalDataLoaded() const override { return m_raw_buffer.size(); }
    bool hasResults() const { return m_b_is_output_allocated; }
    bool isInitialized() const { return m_b_initialized; }
    hebench::APIBridge::DataType getDataType() const { return m_data_type; }
 
protected:
    PartialDataLoader();
    void init(hebench::APIBridge::DataType data_type,
              std::size_t input_dim,
              const std::size_t *input_sample_count_per_dim,
              const std::uint64_t *input_count_per_dim,
              std::size_t output_dim,
              const std::uint64_t *output_count_per_dim,
              bool allocate_output);
    void init(const std::string &filename,
              hebench::APIBridge::DataType data_type,
              std::size_t expected_input_dim,
              const std::size_t *max_input_sample_count_per_dim,
              const std::uint64_t *expected_input_count_per_dim,
              std::size_t expected_output_dim,
              const std::uint64_t *expected_output_count_per_dim);
 
    std::vector<std::shared_ptr<hebench::APIBridge::DataPack>> getResultTempDataPacks(std::uint64_t result_index) const;
    std::vector<std::shared_ptr<hebench::APIBridge::DataPack>> getResultTempDataPacks(const std::uint64_t *param_data_pack_indices) const
    {
        return getResultTempDataPacks(getResultIndex(param_data_pack_indices));
    }
    std::vector<std::shared_ptr<hebench::APIBridge::DataPack>> getResultTempDataPacks() const
    {
        return getResultTempDataPacks(0UL);
    }
 
private:
    void allocate(const std::uint64_t *input_buffer_sizes,
                  std::size_t input_buffer_sizes_count,
                  const std::uint64_t *output_buffer_sizes,
                  std::size_t output_buffer_sizes_count,
                  bool allocate_output);
 
    std::vector<unique_ptr_custom_deleter<hebench::APIBridge::DataPack>> m_input_data;
    // output data is ordered such that each element of the data pack
    // is the result of the input parameters picked in row major order
    std::vector<unique_ptr_custom_deleter<hebench::APIBridge::DataPack>> m_output_data;
    // RAII storage for native data buffers
    std::vector<std::uint8_t> m_raw_buffer; // used to store all the data in contiguous memory
    hebench::APIBridge::DataType m_data_type;
    bool m_b_is_output_allocated;
    bool m_b_initialized;
};
 
} // namespace TestHarness
} // namespace hebench
 
#endif // defined _HEBench_Harness_IDataLoader_H_0596d40a3cce4b108a81595c50eb286d