From 1386d059d1a2cd6eebb40fd9a044dc8d94086f96 Mon Sep 17 00:00:00 2001 From: Dmitriy Zaytsev Date: Sun, 8 Nov 2026 18:35:54 +0300 Subject: [PATCH] add packet-copy benchmark examples --- benchmarks/memory/BUILD.bazel | 1 + benchmarks/memory/memcpy_benchmark.cpp | 46 ++++++++++++++++++++++++ lib/buffers/BUILD.bazel | 18 ++++++++++ lib/buffers/README.md | 19 ++++++++++ lib/buffers/abstract_buffer.hpp | 42 ++++++++++++++++++++++ lib/buffers/buffers_test.cpp | 50 ++++++++++++++++++++++++++ 6 files changed, 176 insertions(+) create mode 100644 lib/buffers/BUILD.bazel create mode 100644 lib/buffers/README.md create mode 100644 lib/buffers/abstract_buffer.hpp create mode 100644 lib/buffers/buffers_test.cpp diff --git a/benchmarks/memory/BUILD.bazel b/benchmarks/memory/BUILD.bazel index 8f54468..723faa6 100644 --- a/benchmarks/memory/BUILD.bazel +++ b/benchmarks/memory/BUILD.bazel @@ -6,6 +6,7 @@ cc_binary( deps = [ "//lib/memory:memcpy", "//lib/memory/copy:copy", + "//lib/buffers:abstract", "@google_benchmark//:benchmark_main", ], ) diff --git a/benchmarks/memory/memcpy_benchmark.cpp b/benchmarks/memory/memcpy_benchmark.cpp index b35c7f7..193481a 100644 --- a/benchmarks/memory/memcpy_benchmark.cpp +++ b/benchmarks/memory/memcpy_benchmark.cpp @@ -1,8 +1,10 @@ +#include "lib/buffers/abstract_buffer.hpp" #include "lib/memory/copy/copy.h" #include "lib/memory/memcpy.h" #include #include +#include #include #include @@ -49,6 +51,32 @@ template void BM_CopyFixed(benchmark::State &state) { static_cast(size)); } +template +void BM_CopyPacket(benchmark::State &state) { + using Packet = buffers::abstract_buffer::AbstractPacket; + typename Packet::AbstractHeader header; + const std::vector source = MakeInput(HeaderLen + PayloadLen); + std::vector destination(PayloadLen); + + for (auto _ : state) { + const auto *payload = + Packet::stripHeader(source.data(), source.size(), header); + + if (payload == nullptr) { + state.SkipWithError("Failed to strip the packet header"); + return; + } + + CopyFn(destination.data(), payload, PayloadLen); + benchmark::DoNotOptimize(header); + benchmark::DoNotOptimize(destination.data()); + benchmark::ClobberMemory(); + } + + state.SetBytesProcessed(static_cast(state.iterations()) * + static_cast(HeaderLen + PayloadLen)); +} + inline void *CopyNaiveWrapper(void *d, const void *s, std::size_t n) { return memory_bench::copy_naive(d, s, n); } @@ -74,6 +102,16 @@ template void RegisterAllBMCopyFixed(const char *name) { RegisterBMCopyFixed(name); } +template +void RegisterBMCopyPacket(const char *name) { + const std::string prefix = + std::string(name) + "/" + std::to_string(HeaderLen) + "/"; + (benchmark::RegisterBenchmark( + (prefix + std::to_string(PayloadLens)).c_str(), + BM_CopyPacket), + ...); +} + static const bool Registered = [] { RegisterBMCopy("BM_Memcpy"); RegisterBMCopy("BM_CopyNaive"); @@ -99,6 +137,14 @@ static const bool RegisteredFixed = [] { return true; }(); +static const bool RegisteredFixedPackets = [] { + RegisterBMCopyPacket( + "BM_CopyPacket_Memcpy"); + RegisterBMCopyPacket( + "BM_CopyPacket_Naive"); + return true; +}(); + #if defined(__x86_64__) || defined(_M_X64) static const bool x86Registered = [] { RegisterBMCopy("BM_CopyRepMovsb"); diff --git a/lib/buffers/BUILD.bazel b/lib/buffers/BUILD.bazel new file mode 100644 index 0000000..5a66d77 --- /dev/null +++ b/lib/buffers/BUILD.bazel @@ -0,0 +1,18 @@ +load("@rules_cc//cc:cc_library.bzl", "cc_library") +load("@rules_cc//cc:cc_test.bzl", "cc_test") + +cc_library( + name = "abstract", + hdrs = ["abstract_buffer.hpp"], + visibility = ["//visibility:public"], +) + +cc_test( + name = "buffers_test", + size = "small", + srcs = ["buffers_test.cpp"], + deps = [ + ":abstract", + "@googletest//:gtest_main", + ], +) diff --git a/lib/buffers/README.md b/lib/buffers/README.md new file mode 100644 index 0000000..d9e06da --- /dev/null +++ b/lib/buffers/README.md @@ -0,0 +1,19 @@ +# Buffers + +The customers asked for benchmarks that better represent a real telecom network +stack. Our idea was to measure packet header assembly alongside memory +copying. For example, benchmark can extract the header before copying +the payload. + +## `AbstractPacket` + +`AbstractPacket` is a mock packet for tests and benchmarks. It models an +`N`-byte header followed by an `M`-byte payload. Both sizes are positive +compile-time constants. + +- `AbstractHeader` stores the `N` raw header bytes in `data`. +- `stripHeader(rawPtr, rawSize, header)` copies the first `N` bytes into + `header.data` and returns a pointer to the payload in the input buffer. + It returns `nullptr` if `rawPtr` is null or `rawSize` is less than `N + M`. + +This mock can later be replaced with a GTP-U or PDCP implementation. diff --git a/lib/buffers/abstract_buffer.hpp b/lib/buffers/abstract_buffer.hpp new file mode 100644 index 0000000..db9f869 --- /dev/null +++ b/lib/buffers/abstract_buffer.hpp @@ -0,0 +1,42 @@ +#pragma once + +#include +#include +#include + +namespace buffers::abstract_buffer { + +/// @brief Fixed-size packet layout. +/// @tparam N header bytes +/// @tparam M payload (user data) bytes +template +class AbstractPacket { + static_assert(N > 0, "N must be greater than 0"); + static_assert(M > 0, "M must be greater than 0"); + + public: + struct AbstractHeader { + std::byte data[N] { std::byte(0) }; + }; + + /// Parses the header and returns a pointer to the payload in the buffer. + /// @param rawPtr Start of the input buffer. + /// @param rawSize Number of readable bytes starting at rawPtr. + /// @param header Packet header. + /// @return Pointer to packet payload on success or nullptr otherwise. + static const std::byte* stripHeader(const std::byte* rawPtr, + std::size_t rawSize, + AbstractHeader& header) { + if (rawPtr == nullptr || rawSize < N + M) { + return nullptr; + } + + for (unsigned i = 0; i < N; i++) { + header.data[i] = rawPtr[i]; + } + + return rawPtr + N; + } +}; + +} // namespace buffers::abstract_buffer diff --git a/lib/buffers/buffers_test.cpp b/lib/buffers/buffers_test.cpp new file mode 100644 index 0000000..b9df2c2 --- /dev/null +++ b/lib/buffers/buffers_test.cpp @@ -0,0 +1,50 @@ +#include +#include + +#include "gtest/gtest.h" +#include "lib/buffers/abstract_buffer.hpp" + +namespace buffers::abstract_buffer { +namespace { + +using Packet = AbstractPacket<2, 4>; + +constexpr std::array kRawPacket = { + std::byte{0x01}, std::byte{0x02}, std::byte{0xA1}, + std::byte{0xA2}, std::byte{0xA3}, std::byte{0xA4}}; + +TEST(AbstractPacketTest, CopyHeaderAndReturnPayloadInInputBuffer) { + auto header = Packet::AbstractHeader(); + + const auto* payload = + Packet::stripHeader(kRawPacket.data(), kRawPacket.size(), header); + + EXPECT_EQ(header.data[0], kRawPacket[0]); + EXPECT_EQ(header.data[1], kRawPacket[1]); + EXPECT_EQ(payload, kRawPacket.data() + 2); +} + +TEST(AbstractPacketTest, RejectNullBuffer) { + auto header = Packet::AbstractHeader(); + + EXPECT_EQ(Packet::stripHeader(nullptr, kRawPacket.size(), header), nullptr); +} + +TEST(AbstractPacketTest, RejectTruncatedHeaderOrPayload) { + std::array kShortHeader = {std::byte{0x01}}; + std::array kShortPayload = { + std::byte{0x01}, std::byte{0x02}, std::byte{0xA1}, std::byte{0xA2}, + std::byte{0xA3}}; + auto header = Packet::AbstractHeader(); + + EXPECT_EQ( + Packet::stripHeader(kShortHeader.data(), kShortHeader.size(), header), + nullptr); + + EXPECT_EQ( + Packet::stripHeader(kShortPayload.data(), kShortPayload.size(), header), + nullptr); +} + +} // namespace +} // namespace buffers::abstract_buffer