Bigfoot/Bigfoot/Benchmarks/Engine/BigFile/BigFile.cpp

#include <Engine/BigFile/BigFile.hpp>

#include <System/File.hpp>
#include <System/UUID/UUID.hpp>

#include <EngineBenchmarks/BigFileInfo_generated.hpp>

#include <AssetsForBenchmarking/Asset/BenchmarkAsset.hpp>

#include <EASTL/vector.h>
#include <benchmark/benchmark.h>
#include <effolkronium/random.hpp>

#include <cstddef>
#include <cstdint>

namespace Bigfoot
{
#ifdef BIGFOOT_TOOLMODE
namespace
{
using Random = effolkronium::random_static;

constexpr std::uint32_t ASSET_COUNT = 20'000;
constexpr std::size_t ASSET_PAYLOAD_SIZE = 256;

class Fixture: public benchmark::Fixture
{
  public:
    void SetUp(benchmark::State&) override
    {
        BigFile::Request {m_bigFile, "DELETE FROM Asset;"}.Execute();
        BigFile::Request {m_bigFile, "DELETE FROM AssetMetadata;"}.Execute();

        m_uuids.clear();
        m_uuids.reserve(ASSET_COUNT);

        eastl::vector<AssetMetadata> metadatas;
        eastl::vector<eastl::vector<std::byte>> flatbuffers;
        metadatas.reserve(ASSET_COUNT);
        flatbuffers.reserve(ASSET_COUNT);

        for (std::uint32_t i = 0; i < ASSET_COUNT; ++i)
        {
            BenchmarkAsset asset;
            asset.SetName(asset.GetHeader().uuid.ToString().c_str());
            asset.GetAsset().payload.assign(ASSET_PAYLOAD_SIZE, std::uint8_t {0xAB});

            metadatas.push_back(AssetMetadata {.m_uuid = asset.GetHeader().uuid,
                                               .m_name = asset.GetHeader().name,
                                               .m_typeID = asset.GetHeader().type_id,
                                               .m_typeName = asset.GetHeader().type_name});
            flatbuffers.push_back(asset.Pack());
            m_uuids.push_back(asset.GetHeader().uuid);
        }

        m_bigFile.SaveAssetFlatbuffers(metadatas, flatbuffers);
    }

  protected:
    [[nodiscard]]
    eastl::vector<UUID> RandomBatch(const std::size_t p_batchSize) const
    {
        eastl::vector<UUID> batch;
        batch.reserve(p_batchSize);
        for (std::size_t i = 0; i < p_batchSize; ++i)
        {
            batch.push_back(m_uuids[Random::get<std::size_t>(0, m_uuids.size() - 1)]);
        }

        return batch;
    }

    BigFile m_bigFile {File {BIGFILE_ENGINEBENCHMARKS_LOCATION}};
    eastl::vector<UUID> m_uuids;
};
}   // namespace

/****************************************************************************************/

BENCHMARK_DEFINE_F(Fixture, GetAssetFlatbuffer)(benchmark::State& state)
{
    std::int64_t bytesProcessed = 0;

    for (auto _: state)
    {
        eastl::optional<eastl::vector<std::byte>> flatbuffer = m_bigFile.GetAssetFlatbuffer(
            m_uuids[Random::get<std::size_t>(0, m_uuids.size() - 1)]);
        benchmark::DoNotOptimize(flatbuffer);

        if (flatbuffer.has_value())
        {
            bytesProcessed += static_cast<std::int64_t>(flatbuffer->size());
        }
    }

    state.SetItemsProcessed(state.iterations());
    state.SetBytesProcessed(bytesProcessed);
}

BENCHMARK_REGISTER_F(Fixture, GetAssetFlatbuffer)->Name("BigFile/GetAssetFlatbuffer");

/****************************************************************************************/

BENCHMARK_DEFINE_F(Fixture, GetAssetFlatbuffers)(benchmark::State& state)
{
    const auto batchSize = static_cast<std::size_t>(state.range(0));
    std::int64_t bytesProcessed = 0;

    for (auto _: state)
    {
        state.PauseTiming();
        const eastl::vector<UUID> batch = RandomBatch(batchSize);
        state.ResumeTiming();

        eastl::vector<eastl::vector<std::byte>> flatbuffers = m_bigFile.GetAssetFlatbuffers(batch);
        benchmark::DoNotOptimize(flatbuffers);

        for (const eastl::vector<std::byte>& flatbuffer: flatbuffers)
        {
            bytesProcessed += static_cast<std::int64_t>(flatbuffer.size());
        }
    }

    state.SetItemsProcessed(state.iterations() * batchSize);
    state.SetBytesProcessed(bytesProcessed);
}

BENCHMARK_REGISTER_F(Fixture, GetAssetFlatbuffers)
    ->Name("BigFile/GetAssetFlatbuffers")
    ->Arg(1)
    ->Arg(8)
    ->Arg(64)
    ->Arg(512)
    ->Arg(4096);

/****************************************************************************************/

BENCHMARK_DEFINE_F(Fixture, GetAssetMetadata)(benchmark::State& state)
{
    for (auto _: state)
    {
        benchmark::DoNotOptimize(m_bigFile.GetAssetMetadata(m_uuids[Random::get<std::size_t>(0, m_uuids.size() - 1)]));
    }

    state.SetItemsProcessed(state.iterations());
}

BENCHMARK_REGISTER_F(Fixture, GetAssetMetadata)->Name("BigFile/GetAssetMetadata");

/****************************************************************************************/

BENCHMARK_DEFINE_F(Fixture, GetAssetMetadatas)(benchmark::State& state)
{
    const auto batchSize = static_cast<std::size_t>(state.range(0));

    for (auto _: state)
    {
        state.PauseTiming();
        const eastl::vector<UUID> batch = RandomBatch(batchSize);
        state.ResumeTiming();

        benchmark::DoNotOptimize(m_bigFile.GetAssetMetadatas(batch));
    }

    state.SetItemsProcessed(state.iterations() * batchSize);
}

BENCHMARK_REGISTER_F(Fixture, GetAssetMetadatas)
    ->Name("BigFile/GetAssetMetadatas")
    ->Arg(1)
    ->Arg(8)
    ->Arg(64)
    ->Arg(512)
    ->Arg(4096);

/****************************************************************************************/

BENCHMARK_DEFINE_F(Fixture, SaveAssetFlatbuffer)(benchmark::State& state)
{
    std::int64_t bytesProcessed = 0;

    for (auto _: state)
    {
        state.PauseTiming();
        BenchmarkAsset asset;
        asset.SetName(asset.GetHeader().uuid.ToString().c_str());
        asset.GetAsset().payload.assign(ASSET_PAYLOAD_SIZE, std::uint8_t {0xAB});

        const AssetMetadata metadata {.m_uuid = asset.GetHeader().uuid,
                                      .m_name = asset.GetHeader().name,
                                      .m_typeID = asset.GetHeader().type_id,
                                      .m_typeName = asset.GetHeader().type_name};
        const eastl::vector<std::byte> flatbuffer = asset.Pack();
        bytesProcessed += static_cast<std::int64_t>(flatbuffer.size());
        state.ResumeTiming();

        m_bigFile.SaveAssetFlatbuffer(metadata, flatbuffer);
    }

    state.SetItemsProcessed(state.iterations());
    state.SetBytesProcessed(bytesProcessed);
}

BENCHMARK_REGISTER_F(Fixture, SaveAssetFlatbuffer)->Name("BigFile/SaveAssetFlatbuffer");

/****************************************************************************************/

BENCHMARK_DEFINE_F(Fixture, SaveAssetFlatbuffers)(benchmark::State& state)
{
    const auto batchSize = static_cast<std::size_t>(state.range(0));
    std::int64_t bytesProcessed = 0;

    for (auto _: state)
    {
        state.PauseTiming();
        eastl::vector<AssetMetadata> metadatas;
        eastl::vector<eastl::vector<std::byte>> flatbuffers;
        metadatas.reserve(batchSize);
        flatbuffers.reserve(batchSize);

        for (std::size_t i = 0; i < batchSize; ++i)
        {
            BenchmarkAsset asset;
            asset.SetName(asset.GetHeader().uuid.ToString().c_str());
            asset.GetAsset().payload.assign(ASSET_PAYLOAD_SIZE, std::uint8_t {0xAB});

            metadatas.push_back(AssetMetadata {.m_uuid = asset.GetHeader().uuid,
                                               .m_name = asset.GetHeader().name,
                                               .m_typeID = asset.GetHeader().type_id,
                                               .m_typeName = asset.GetHeader().type_name});
            flatbuffers.push_back(asset.Pack());
            bytesProcessed += static_cast<std::int64_t>(flatbuffers.back().size());
        }
        state.ResumeTiming();

        m_bigFile.SaveAssetFlatbuffers(metadatas, flatbuffers);
    }

    state.SetItemsProcessed(state.iterations() * batchSize);
    state.SetBytesProcessed(bytesProcessed);
}

BENCHMARK_REGISTER_F(Fixture, SaveAssetFlatbuffers)
    ->Name("BigFile/SaveAssetFlatbuffers")
    ->Arg(1)
    ->Arg(8)
    ->Arg(64)
    ->Arg(512)
    ->Arg(4096);
#endif
}   // namespace Bigfoot