Bigfoot/Bigfoot/Benchmarks/Engine/Sasquatch/Sasquatch.cpp

/*********************************************************************
 * \file   Sasquatch.cpp
 *
 * \author Romain BOULLARD
 * \date   August 2026
 *********************************************************************/
#include <Engine/Sasquatch/Sasquatch.hpp>

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

#include <EngineBenchmarks/SasquatchInfo_generated.hpp>

#include <AssetsForBenchmarking/Asset/BenchmarkAsset.hpp>

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

#include <cstddef>
#include <cstdint>

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

class SasquatchFixture: public benchmark::Fixture
{
  protected:
    static constexpr std::uint32_t ASSET_COUNT = 20'000;
    static constexpr std::size_t ASSET_PAYLOAD_SIZE = 256;

    void SetUp([[maybe_unused]] benchmark::State& p_state) override
    {
        File {SASQUATCH_ENGINEBENCHMARKS_LOCATION}.Delete();

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

        m_uuids.clear();
        m_uuids.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});

            flatbuffers.push_back(asset.Pack());
            m_uuids.push_back(asset.GetHeader().uuid);
        }

        eastl::vector<SasquatchData> assets;
        assets.reserve(ASSET_COUNT);
        for (std::uint32_t i = 0; i < ASSET_COUNT; ++i)
        {
            assets.push_back(SasquatchData {.m_uuid = m_uuids[i], .m_flatbuffer = flatbuffers[i]});
        }

        std::uint64_t totalFlatbufferBytes = 0;
        for (const SasquatchData& asset: assets)
        {
            totalFlatbufferBytes += asset.m_flatbuffer.size();
        }

        {
            SasquatchWriter writer {File {SASQUATCH_ENGINEBENCHMARKS_LOCATION}, assets.size(), totalFlatbufferBytes};
            for (const SasquatchData& asset: assets)
            {
                writer.WriteAsset(asset.m_uuid, asset.m_flatbuffer);
            }
        }

        m_sasquatch.emplace(File {SASQUATCH_ENGINEBENCHMARKS_LOCATION});
    }

    void TearDown(benchmark::State&) override
    {
        m_sasquatch.reset();
    }

    [[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;
    }

    [[nodiscard]]
    eastl::vector<eastl::vector<UUID>> RandomBatchPool(const std::size_t p_batchSize,
                                                       const std::size_t p_poolSize) const
    {
        eastl::vector<eastl::vector<UUID>> pool;
        pool.reserve(p_poolSize);
        for (std::size_t i = 0; i < p_poolSize; ++i)
        {
            pool.push_back(RandomBatch(p_batchSize));
        }

        return pool;
    }

    eastl::optional<Sasquatch> m_sasquatch;
    eastl::vector<UUID> m_uuids;
};

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

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

    for (auto _: state)
    {
        eastl::optional<eastl::vector<std::byte>> flatbuffer = m_sasquatch->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(SasquatchFixture, GetAssetFlatbuffer)->Name("Sasquatch/GetAssetFlatbuffer");

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

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

    constexpr std::size_t BATCH_POOL_SIZE = 64;
    const eastl::vector<eastl::vector<UUID>> batchPool = RandomBatchPool(batchSize, BATCH_POOL_SIZE);

    std::int64_t bytesProcessed = 0;
    std::size_t batchIndex = 0;

    for (auto _: state)
    {
        eastl::vector<eastl::vector<std::byte>> flatbuffers = m_sasquatch->GetAssetFlatbuffers(batchPool[batchIndex]);
        benchmark::DoNotOptimize(flatbuffers);

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

        batchIndex = (batchIndex + 1) % BATCH_POOL_SIZE;
    }

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

BENCHMARK_REGISTER_F(SasquatchFixture, GetAssetFlatbuffers)
    ->Name("Sasquatch/GetAssetFlatbuffers")
    ->Arg(1)
    ->Arg(8)
    ->Arg(64)
    ->Arg(512)
    ->Arg(4096);
#endif
}   // namespace Bigfoot