datagen_helper.h

Go to the documentation of this file.

 
// Copyright (C) 2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
 
#ifndef _HEBench_Harness_DataGenHelper_H_0596d40a3cce4b108a81595c50eb286d
#define _HEBench_Harness_DataGenHelper_H_0596d40a3cce4b108a81595c50eb286d
 
#include <cmath>
#include <mutex>
#include <set>
#include <string>
#include <type_traits>
 
#include "hebench/modules/logging/include/logging.h"
 
#include "hebench/api_bridge/types.h"
#include "include/hebench_idata_loader.h"
 
namespace hebench {
namespace TestHarness {
 
class DataLoaderCompute : public hebench::TestHarness::PartialDataLoader
{
public:
    DISABLE_COPY(DataLoaderCompute)
    DISABLE_MOVE(DataLoaderCompute)
private:
    IL_DECLARE_CLASS_NAME(DataLoaderCompute)
public:
    ~DataLoaderCompute() override {}
    ResultDataPtr getResultFor(const std::uint64_t *param_data_pack_indices) override;
 
protected:
    DataLoaderCompute() {}
 
    virtual void computeResult(std::vector<hebench::APIBridge::NativeDataBuffer *> &result,
                               const std::uint64_t *param_data_pack_indices,
                               hebench::APIBridge::DataType data_type) = 0;
 
private:
    // can we find a thread friendly/safe solution?
    std::vector<std::shared_ptr<hebench::APIBridge::DataPack>> &getLocalTempResult();
    std::shared_ptr<std::vector<std::shared_ptr<hebench::APIBridge::DataPack>>> m_p_temp_result;
};
 
class DataGeneratorHelper
{
private:
    IL_DECLARE_CLASS_NAME(DataGeneratorHelper)
 
public:
    virtual ~DataGeneratorHelper() = default;
 
    static void generateRandomVectorU(hebench::APIBridge::DataType data_type,
                                      void *result, std::uint64_t elem_count,
                                      double min_val, double max_val);
 
    static void generateRandomVectorN(hebench::APIBridge::DataType data_type,
                                      void *result, std::uint64_t elem_count,
                                      double mean, double stddev);
 
    static std::uint64_t generateRandomIntU(std::uint64_t min_val, std::uint64_t max_val);
 
    static std::vector<std::uint64_t> generateRandomIntersectionIndicesU(std::uint64_t elem_count, std::uint64_t indices_count = 0);
 
protected:
    DataGeneratorHelper() = default;
 
private:
    template <class T>
    static void generateRandomVectorU(T *result, std::uint64_t elem_count,
                                      T min_val, T max_val);
    template <class T>
    static void generateRandomVectorN(T *result, std::uint64_t elem_count,
                                      T mean, T stddev);
 
private:
    static std::mutex m_mtx_rand;
};
 
} // namespace TestHarness
} // namespace hebench
 
#endif // defined _HEBench_Harness_DataGenerator_H_0596d40a3cce4b108a81595c50eb286d