More optimizations for BigFile

Bigfoot/Benchmarks/Engine/BigFile/BigFile.cpp

@@ -0,0 +1,253 @@
+#include <Engine/BigFile/BigFile.hpp>
+
+#include <AssetsForBenchmarking/Asset/BenchmarkAsset.hpp>
+#include <EngineBenchmarks/BigFileInfo_generated.hpp>
+
+#include <System/File.hpp>
+#include <System/UUID/UUID.hpp>
+
+#include <EASTL/vector.h>
+#include <effolkronium/random.hpp>
+
+#include <benchmark/benchmark.h>
+
+#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

Bigfoot/Benchmarks/Engine/CMakeLists.txt

@@ -0,0 +1,12 @@
+get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
+project(${PackageName}Benchmarks)
+
+bigfoot_create_package_benchmarks(
+    "")
+
+target_link_libraries(${PROJECT_NAME}
+    PRIVATE
+        effolkronium_random
+        $<LINK_LIBRARY:WHOLE_ARCHIVE,AssetsForBenchmarking>)
+
+bigfoot_create_bigfile("Benchmarks/Bigfoot")

Bigfoot/Benchmarks/Engine/Include/EngineBenchmarks/BigFileInfo_generated.hpp

@@ -0,0 +1,19 @@
+// AUTO-GENERATED DO NOT TOUCH
+
+/*********************************************************************
+ * \file   BigFileInfo.generated.hpp
+ *
+ *********************************************************************/
+#ifndef BIGFOOT_ENGINEBENCHMARKS_BIGFILEINFO_GENERATED_HPP
+#define BIGFOOT_ENGINEBENCHMARKS_BIGFILEINFO_GENERATED_HPP
+
+#include <EASTL/string_view.h>
+
+namespace Bigfoot
+{
+/*
+ * BigFile location
+ */
+constexpr eastl::string_view BIGFILE_ENGINEBENCHMARKS_LOCATION {"./EngineBenchmarks-bigfile.db"};
+}  // namespace Bigfoot
+#endif