Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions benchmarks/memory/BUILD.bazel
Original file line number Diff line number Diff line change
Expand Up @@ -6,6 +6,7 @@ cc_binary(
deps = [
"//lib/memory:memcpy",
"//lib/memory/copy:copy",
"//lib/buffers:abstract",
"@google_benchmark//:benchmark_main",
],
)
46 changes: 46 additions & 0 deletions benchmarks/memory/memcpy_benchmark.cpp
Original file line number Diff line number Diff line change
@@ -1,8 +1,10 @@
#include "lib/buffers/abstract_buffer.hpp"
#include "lib/memory/copy/copy.h"
#include "lib/memory/memcpy.h"

#include <cstddef>
#include <cstdint>
#include <string>
#include <vector>

#include <benchmark/benchmark.h>
Expand Down Expand Up @@ -49,6 +51,32 @@ template <auto CopyFn, size_t Len> void BM_CopyFixed(benchmark::State &state) {
static_cast<std::int64_t>(size));
}

template <auto CopyFn, std::size_t HeaderLen, std::size_t PayloadLen>
void BM_CopyPacket(benchmark::State &state) {
using Packet = buffers::abstract_buffer::AbstractPacket<HeaderLen, PayloadLen>;
typename Packet::AbstractHeader header;
const std::vector<std::byte> source = MakeInput(HeaderLen + PayloadLen);
std::vector<std::byte> 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<std::int64_t>(state.iterations()) *
static_cast<std::int64_t>(HeaderLen + PayloadLen));
}

inline void *CopyNaiveWrapper(void *d, const void *s, std::size_t n) {
return memory_bench::copy_naive(d, s, n);
}
Expand All @@ -74,6 +102,16 @@ template <auto Fn> void RegisterAllBMCopyFixed(const char *name) {
RegisterBMCopyFixed<Fn, 64, 64 << 20, 4>(name);
}

template <auto Fn, std::size_t HeaderLen, std::size_t... PayloadLens>
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<Fn, HeaderLen, PayloadLens>),
...);
}

static const bool Registered = [] {
RegisterBMCopy<memcopy_bench::memory::CopyWithMemcpy>("BM_Memcpy");
RegisterBMCopy<CopyNaiveWrapper>("BM_CopyNaive");
Expand All @@ -99,6 +137,14 @@ static const bool RegisteredFixed = [] {
return true;
}();

static const bool RegisteredFixedPackets = [] {
RegisterBMCopyPacket<memcopy_bench::memory::CopyWithMemcpy, 16, 64, 512, 1500>(
"BM_CopyPacket_Memcpy");
RegisterBMCopyPacket<CopyNaiveWrapper, 16, 64, 512, 1500>(
"BM_CopyPacket_Naive");
return true;
}();

#if defined(__x86_64__) || defined(_M_X64)
static const bool x86Registered = [] {
RegisterBMCopy<memory_bench::copy_rep_movsb>("BM_CopyRepMovsb");
Expand Down
18 changes: 18 additions & 0 deletions lib/buffers/BUILD.bazel
Original file line number Diff line number Diff line change
@@ -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",
],
)
19 changes: 19 additions & 0 deletions lib/buffers/README.md
Original file line number Diff line number Diff line change
@@ -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<N, M>` 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.
42 changes: 42 additions & 0 deletions lib/buffers/abstract_buffer.hpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,42 @@
#pragma once

#include <algorithm>
#include <cstddef>
#include <limits>

namespace buffers::abstract_buffer {

/// @brief Fixed-size packet layout.
/// @tparam N header bytes
/// @tparam M payload (user data) bytes
template <std::size_t N, std::size_t M>
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
50 changes: 50 additions & 0 deletions lib/buffers/buffers_test.cpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,50 @@
#include <array>
#include <cstddef>

#include "gtest/gtest.h"
#include "lib/buffers/abstract_buffer.hpp"

namespace buffers::abstract_buffer {
namespace {

using Packet = AbstractPacket<2, 4>;

constexpr std::array<std::byte, 6> 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<std::byte, 1> kShortHeader = {std::byte{0x01}};
std::array<std::byte, 5> 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