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 <AssetsForBenchmarking/Asset/BenchmarkAsset.hpp>
#include <AssetsForBenchmarking/Asset/BenchmarkAssetReferred.hpp>

#include <EngineBenchmarks/SasquatchInfo_generated.hpp>

#include <EASTL/optional.h>
#include <EASTL/span.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::uint32_t REFS_PER_ASSET = 4;
    static constexpr std::size_t ASSET_PAYLOAD_SIZE = 256;

    void SetUp([[maybe_unused]] benchmark::State& p_state) override
    {
        // The Sasquatch file is built exactly once for the entire benchmark process.
        // SetUp is called before every calibration round (Google Benchmark doubles
        // iteration counts until it reaches a stable measurement), so rebuilding
        // the file each time would dominate the total benchmark time.
        m_uuids = BuildData();
        m_sasquatch.emplace(File {SASQUATCH_ENGINEBENCHMARKS_LOCATION});
    }

    void TearDown([[maybe_unused]] benchmark::State& p_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::span<const UUID> m_uuids;

  private:
    static const eastl::vector<UUID>& BuildData()
    {
        static const eastl::vector<UUID> s_uuids = []()
        {
            File {SASQUATCH_ENGINEBENCHMARKS_LOCATION}.Delete();

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

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

                    asset.GetAsset().refs.emplace_back(assetReferred.GetHeader().uuid);
                }

                eastl::vector<std::byte> flatbuffer = asset.Pack();
                hardReferences.push_back(asset.GetHardReferences(flatbuffer));
                flatbuffers.push_back(std::move(flatbuffer));
                uuids.push_back(asset.GetHeader().uuid);
            }

            std::size_t totalFlatbufferBytes = 0;
            std::size_t totalHardReferencesBytes = 0;
            for (std::size_t i = 0; i < uuids.size(); ++i)
            {
                totalFlatbufferBytes += flatbuffers[i].size();
                totalHardReferencesBytes += hardReferences[i].size() * UUID::UUID_BYTE_SIZE;
            }

            SasquatchWriter writer {File {SASQUATCH_ENGINEBENCHMARKS_LOCATION},
                                    uuids.size(),
                                    totalFlatbufferBytes,
                                    totalHardReferencesBytes};
            for (std::size_t i = 0; i < uuids.size(); ++i)
            {
                writer.WriteAsset(uuids[i], flatbuffers[i], hardReferences[i]);
            }

            return uuids;
        }();

        return s_uuids;
    }
};

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

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

    state.SetItemsProcessed(state.iterations());
    state.SetBytesProcessed(static_cast<std::int64_t>(state.iterations()) * REFS_PER_ASSET * UUID::UUID_BYTE_SIZE);
}

BENCHMARK_REGISTER_F(SasquatchFixture, GetAssetHardReferences)->Name("Sasquatch/GetAssetHardReferences")->UseRealTime();

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

BENCHMARK_DEFINE_F(SasquatchFixture, GetAssetsHardReferences)(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::size_t batchIndex = 0;
    for (auto _: state)
    {
        benchmark::DoNotOptimize(m_sasquatch->GetAssetsHardReferences(batchPool[batchIndex]));
        batchIndex = (batchIndex + 1) % BATCH_POOL_SIZE;
    }

    state.SetItemsProcessed(state.iterations() * batchSize);
    state.SetBytesProcessed(static_cast<std::int64_t>(state.iterations()) * batchSize * REFS_PER_ASSET *
                            UUID::UUID_BYTE_SIZE);
}

BENCHMARK_REGISTER_F(SasquatchFixture, GetAssetsHardReferences)
    ->Name("Sasquatch/GetAssetsHardReferences")
    ->Arg(1)
    ->Arg(8)
    ->Arg(64)
    ->Arg(512)
    ->Arg(4096)
    ->UseRealTime();

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

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

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

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

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

BENCHMARK_REGISTER_F(SasquatchFixture, GetAssetFlatbuffer)->Name("Sasquatch/GetAssetFlatbuffer")->UseRealTime();

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

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)
    ->UseRealTime();
#endif
}   // namespace Bigfoot