Add a benchmark which uses Google benchmark library

.github/workflows/build_and_test.yml

@@ -104,7 +104,7 @@ jobs:
             ${{ matrix.image }}-ccache
 
       - name: Configure PcapPlusPlus
-        run: cmake -DLIGHT_PCAPNG_ZSTD=${{ matrix.config-zstd }} -DPCAPPP_BUILD_COVERAGE=ON ${{ matrix.additional-flags }} -S . -B "$BUILD_DIR"
+        run: cmake -DPCAPPP_USE_GOOGLEBENCHMARK=ON -DLIGHT_PCAPNG_ZSTD=${{ matrix.config-zstd }} -DPCAPPP_BUILD_COVERAGE=ON ${{ matrix.additional-flags }} -S . -B "$BUILD_DIR"
 
       - name: Build PcapPlusPlus
         run: cmake --build "$BUILD_DIR" -j

.gitignore

@@ -23,6 +23,7 @@
 *.pcapng.zst
 *.pcapng.zstd
 *.cap
+*.snoop
 
 #Bin and Obj directories
 **/Bin

CMakeLists.txt

@@ -102,6 +102,7 @@ option(PCAPPP_BUILD_TESTS "Build Tests" ${PCAPPP_MAIN_PROJECT})
 option(PCAPPP_BUILD_COVERAGE "Generate Coverage Report" OFF)
 option(PCAPPP_BUILD_FUZZERS "Build Fuzzers binaries" OFF)
 option(PCAPPP_BUILD_REPRODUCIBLE "Build a reproducible version" OFF)
+option(PCAPPP_USE_GOOGLEBENCHMARK "Build benchmarks using Google benchmark" OFF)
 
 option(BUILD_SHARED_LIBS "Build using shared libraries" OFF)
 

Examples/PcapPlusPlus-benchmark/CMakeLists.txt

@@ -1,12 +1,39 @@
-add_executable(benchmark benchmark.cpp)
+add_executable(BenchmarkExample benchmark.cpp)
 
-target_link_libraries(benchmark PUBLIC PcapPlusPlus::Pcap++)
+target_link_libraries(BenchmarkExample PUBLIC PcapPlusPlus::Pcap++)
 
-set_target_properties(benchmark PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${PCAPPP_BINARY_EXAMPLES_DIR}")
+set_target_properties(BenchmarkExample PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${PCAPPP_BINARY_EXAMPLES_DIR}")
+
+if(PCAPPP_USE_GOOGLEBENCHMARK)
+  include(FetchContent)
+
+  # Fetch Google Benchmark
+  fetchcontent_declare(
+    benchmark
+    GIT_REPOSITORY https://github.com/google/benchmark.git
+    GIT_TAG v1.9.0)
+
+  # Disable testing for benchmark
+  set(BENCHMARK_ENABLE_TESTING OFF)
+  fetchcontent_makeavailable(benchmark)
+
+  add_executable(BenchmarkExampleGoogle benchmark-google.cpp)
+
+  target_link_libraries(BenchmarkExampleGoogle PUBLIC PcapPlusPlus::Pcap++ benchmark::benchmark)
+
+  set_target_properties(BenchmarkExampleGoogle PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${PCAPPP_BINARY_EXAMPLES_DIR}")
+endif()
 
 if(PCAPPP_INSTALL)
   install(
-    TARGETS benchmark
+    TARGETS BenchmarkExample
     EXPORT PcapPlusPlusTargets
     RUNTIME DESTINATION ${PCAPPP_INSTALL_BINDIR})
+
+  if(PCAPPP_USE_GOOGLEBENCHMARK)
+    install(
+      TARGETS BenchmarkExampleGoogle
+      EXPORT PcapPlusPlusTargets
+      RUNTIME DESTINATION ${PCAPPP_INSTALL_BINDIR})
+  endif()
 endif()

Examples/PcapPlusPlus-benchmark/README.md

@@ -6,3 +6,12 @@ This is a benchmark application used for measuring PcapPlusPlus performance. It
 See this page for more details: https://pcapplusplus.github.io/docs/benchmark
 
 This application currently compiles on Linux only (where benchmark was running on)
+
+Additionally, there is an integration of Google Benchmark library for benchmarking. For enabling, configure the library with `-DPCAPPP_USE_GOOGLEBENCHMARK=ON`. Each benchmark can be affected from different sources. You can check the table below for more information. If you have performance critical applications which will use PcapPlusPlus, please benchmark it in your environment to get better and more precise results. Also using different pcaps, both in terms of size (larger is better to prevent open/close overhead) and protocol/session variety, can also help to give idea about performance of PcapPlusPlus in your environment.
+
+|     Benchmark     |   Operation   |  Can be affected  |
+|:-----------------:|:-------------:|:-----------------:|
+| BM_PcapFileRead   |     Read      | CPU + Disk (Read) |
+| BM_PcapFileWrite  |     Write     | CPU + Disk (Write)|
+| BM_PacketParsing  | Read + Parse  | CPU + Disk (Read) |
+| BM_PacketCrafting |     Craft     |       CPU         |

Examples/PcapPlusPlus-benchmark/benchmark-google.cpp

@@ -0,0 +1,263 @@
+#include <Packet.h>
+#include <PcapFileDevice.h>
+#include <PcapPlusPlusVersion.h>
+
+#include <EthLayer.h>
+#include <IPv4Layer.h>
+#include <IPv6Layer.h>
+#include <TcpLayer.h>
+#include <UdpLayer.h>
+
+#include <benchmark/benchmark.h>
+
+#include <iostream>
+
+static std::string pcapFileName = "";
+
+static void BM_PcapFileRead(benchmark::State& state)
+{
+	// Open the pcap file for reading
+	pcpp::PcapFileReaderDevice reader(pcapFileName);
+	if (!reader.open())
+	{
+		state.SkipWithError("Cannot open pcap file for reading");
+		return;
+	}
+
+	size_t totalBytes = 0;
+	size_t totalPackets = 0;
+	pcpp::RawPacket rawPacket;
+	for (auto _ : state)
+	{
+		if (!reader.getNextPacket(rawPacket))
+		{
+			// If the rawPacket is empty there should be an error
+			if (totalBytes == 0)
+			{
+				state.SkipWithError("Cannot read packet");
+				break;
+			}
+			else  // If the rawPacket is not empty, it means the file is over
+			{
+				state.PauseTiming();
+				reader.close();
+				reader.open();
+				state.ResumeTiming();
+			}
+		}
+
+		++totalPackets;
+		totalBytes += rawPacket.getRawDataLen();
+	}
+
+	state.SetBytesProcessed(totalBytes);
+	state.SetItemsProcessed(totalPackets);
+}
+BENCHMARK(BM_PcapFileRead);
+
+static void BM_PcapFileWrite(benchmark::State& state)
+{
+	// Open the pcap file for writing
+	pcpp::PcapFileWriterDevice writer("benchmark-output.pcap");
+	if (!writer.open())
+	{
+		state.SkipWithError("Cannot open pcap file for writing");
+		return;
+	}
+
+	pcpp::Packet packet;
+	pcpp::EthLayer ethLayer(pcpp::MacAddress("00:00:00:00:00:00"), pcpp::MacAddress("00:00:00:00:00:00"));
+	pcpp::IPv4Layer ip4Layer(pcpp::IPv4Address("192.168.0.1"), pcpp::IPv4Address("192.168.0.2"));
+	pcpp::TcpLayer tcpLayer(12345, 80);
+
+	packet.addLayer(&ethLayer);
+	packet.addLayer(&ip4Layer);
+	packet.addLayer(&tcpLayer);
+	packet.computeCalculateFields();
+
+	size_t totalBytes = 0;
+	size_t totalPackets = 0;
+	for (auto _ : state)
+	{
+		// Write packet to file
+		writer.writePacket(*(packet.getRawPacket()));
+
+		// Count total bytes and packets
+		++totalPackets;
+		totalBytes += packet.getRawPacket()->getRawDataLen();
+	}
+
+	// Set statistics to the benchmark state
+	state.SetBytesProcessed(totalBytes);
+	state.SetItemsProcessed(totalPackets);
+}
+BENCHMARK(BM_PcapFileWrite);
+
+static void BM_PacketParsing(benchmark::State& state)
+{
+	// Open the pcap file for reading
+	size_t totalBytes = 0;
+	size_t totalPackets = 0;
+	pcpp::PcapFileReaderDevice reader(pcapFileName);
+	if (!reader.open())
+	{
+		state.SkipWithError("Cannot open pcap file for reading");
+		return;
+	}
+
+	pcpp::RawPacket rawPacket;
+	for (auto _ : state)
+	{
+		if (!reader.getNextPacket(rawPacket))
+		{
+			// If the rawPacket is empty there should be an error
+			if (totalBytes == 0)
+			{
+				state.SkipWithError("Cannot read packet");
+				break;
+			}
+			else  // If the rawPacket is not empty, it means the file is over
+			{
+				state.PauseTiming();
+				reader.close();
+				reader.open();
+				state.ResumeTiming();
+				continue;
+			}
+		}
+
+		// Parse packet
+		pcpp::Packet parsedPacket(&rawPacket);
+
+		// Use parsedPacket to prevent compiler optimizations
+		assert(parsedPacket.getFirstLayer());
+
+		// Count total bytes and packets
+		++totalPackets;
+		totalBytes += rawPacket.getRawDataLen();
+	}
+
+	// Set statistics to the benchmark state
+	state.SetBytesProcessed(totalBytes);
+	state.SetItemsProcessed(totalPackets);
+}
+BENCHMARK(BM_PacketParsing);
+
+static void BM_PacketCrafting(benchmark::State& state)
+{
+	size_t totalBytes = 0;
+	size_t totalPackets = 0;
+
+	for (auto _ : state)
+	{
+		uint8_t randNum = static_cast<uint8_t>(rand() % 256);
+
+		// Generate random MAC addresses
+		pcpp::MacAddress srcMac(randNum, randNum, randNum, randNum, randNum, randNum);
+		pcpp::MacAddress dstMac(randNum, randNum, randNum, randNum, randNum, randNum);
+
+		// Craft packet
+		std::unique_ptr<pcpp::EthLayer> ethLayer(new pcpp::EthLayer(srcMac, dstMac));
+
+		std::unique_ptr<pcpp::IPv4Layer> ipv4Layer(nullptr);
+		std::unique_ptr<pcpp::IPv6Layer> ipv6Layer(nullptr);
+
+		std::unique_ptr<pcpp::TcpLayer> tcpLayer(nullptr);
+		std::unique_ptr<pcpp::UdpLayer> udpLayer(nullptr);
+
+		// Randomly choose between IPv4 and IPv6
+		if (randNum % 2)
+		{
+			ipv4Layer.reset(new pcpp::IPv4Layer(randNum, randNum));
+		}
+		else
+		{
+			std::array<uint8_t, 16> srcIP = { randNum, randNum, randNum, randNum, randNum, randNum, randNum, randNum,
+				                              randNum, randNum, randNum, randNum, randNum, randNum, randNum, randNum };
+			std::array<uint8_t, 16> dstIP = { randNum, randNum, randNum, randNum, randNum, randNum, randNum, randNum,
+				                              randNum, randNum, randNum, randNum, randNum, randNum, randNum, randNum };
+
+			ipv6Layer.reset(new pcpp::IPv6Layer(srcIP, dstIP));
+		}
+
+		// Randomly choose between TCP and UDP
+		if (randNum % 2)
+		{
+			tcpLayer.reset(new pcpp::TcpLayer(randNum % 65536, randNum % 65536));
+		}
+		else
+		{
+			udpLayer.reset(new pcpp::UdpLayer(randNum % 65536, randNum % 65536));
+		}
+
+		// Add layers to the packet
+		pcpp::Packet packet;
+		packet.addLayer(ethLayer.get());
+		if (ipv4Layer)
+		{
+			packet.addLayer(ipv4Layer.get());
+		}
+		else
+		{
+			packet.addLayer(ipv6Layer.get());
+		}
+
+		if (tcpLayer)
+		{
+			packet.addLayer(tcpLayer.get());
+		}
+		else
+		{
+			packet.addLayer(udpLayer.get());
+		}
+
+		packet.computeCalculateFields();
+
+		// Count total bytes and packets
+		++totalPackets;
+		totalBytes += packet.getRawPacket()->getRawDataLen();
+	}
+
+	// Set statistics to the benchmark state
+	state.SetBytesProcessed(totalBytes);
+	state.SetItemsProcessed(totalPackets);
+}
+BENCHMARK(BM_PacketCrafting);
+
+int main(int argc, char** argv)
+{
+	// Initialize the benchmark
+	benchmark::Initialize(&argc, argv);
+
+	// Parse command line arguments to find the pcap file name
+	for (int idx = 1; idx < argc; ++idx)
+	{
+		if (strcmp(argv[idx], "--pcap-file") == 0)
+		{
+			if (idx == argc - 1)
+			{
+				std::cerr << "Please provide a pcap file name after --pcap-file" << std::endl;
+				return 1;
+			}
+
+			pcapFileName = argv[idx + 1];
+			break;
+		}
+	}
+
+	if (pcapFileName.empty())
+	{
+		std::cerr << "Please provide a pcap file name using --pcap-file" << std::endl;
+		return 1;
+	}
+
+	benchmark::AddCustomContext("PcapPlusPlus version", pcpp::getPcapPlusPlusVersionFull());
+	benchmark::AddCustomContext("Build info", pcpp::getBuildDateTime());
+	benchmark::AddCustomContext("Git info", pcpp::getGitInfo());
+	benchmark::AddCustomContext("Pcap file", pcapFileName);
+
+	// Run the benchmarks
+	benchmark::RunSpecifiedBenchmarks();
+
+	return 0;
+}

README.md

@@ -27,6 +27,7 @@ PcapPlusPlus enables decoding and forging capabilities for a large variety of ne
   - [Vcpkg](#vcpkg)
   - [Conan](#conan)
   - [Build It Yourself](#build-it-yourself)
+  - [Verify your packages](#verify-your-packages)
 - [Feature Overview](#feature-overview)
 - [Getting Started](#getting-started)
 - [API Documentation](#api-documentation)