Simple parser (micro-)benchmarking

spicy/runtime/CMakeLists.txt

@@ -99,3 +99,7 @@ target_link_libraries(spicy-rt-tests
                       PRIVATE $<IF:$<CONFIG:Debug>,spicy-rt-debug-objects,spicy-rt-objects>)
 target_link_libraries(spicy-rt-tests PRIVATE $<IF:$<CONFIG:Debug>,spicy-rt-debug,spicy-rt> doctest)
 add_test(NAME spicy-rt-tests COMMAND ${PROJECT_BINARY_DIR}/bin/spicy-rt-tests)
+
+if (${USE_BENCHMARK})
+    add_subdirectory(src/benchmarks/)
+endif ()

spicy/runtime/src/benchmarks/CMakeLists.txt

@@ -0,0 +1,23 @@
+# Copyright (c) 2020-now by the Zeek Project. See LICENSE for details.
+
+set(BENCH_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/parsers.spicy")
+set(BENCH_MODULE Benchmark)
+
+list(TRANSFORM BENCH_MODULE PREPEND Benchmark_ OUTPUT_VARIABLE _generated_sources)
+list(TRANSFORM _generated_sources APPEND ".cc" OUTPUT_VARIABLE _generated_sources)
+list(APPEND _generated_sources "Benchmark___linker__.cc")
+
+add_custom_command(
+    OUTPUT ${_generated_sources}
+    COMMAND ${CMAKE_BINARY_DIR}/bin/spicyc -x ${CMAKE_CURRENT_BINARY_DIR}/Benchmark
+            "${BENCH_SOURCES}"
+    DEPENDS spicyc
+    COMMENT "Generating C++ code for Benchmark")
+
+add_executable(spicy-rt-parsing-benchmark parsing.cc ${_generated_sources})
+target_compile_options(spicy-rt-parsing-benchmark PRIVATE "-Wall")
+target_link_libraries(spicy-rt-parsing-benchmark
+                      PRIVATE $<IF:$<CONFIG:Debug>,spicy-rt-debug,spicy-rt>)
+target_link_libraries(spicy-rt-parsing-benchmark
+                      PRIVATE $<IF:$<CONFIG:Debug>,hilti-rt-debug,hilti-rt>)
+target_link_libraries(spicy-rt-parsing-benchmark PRIVATE benchmark)

spicy/runtime/src/benchmarks/parsers.spicy

@@ -0,0 +1,25 @@
+# Copyright (c) 2020-now by the Zeek Project. See LICENSE for details.
+
+module Benchmark;
+
+type Inner = unit {
+    b: b"A";
+};
+
+public type UnitVectorSize = unit {
+    length: uint64;
+    inner: Inner[] &size=self.length;
+    end_: b"BB";
+};
+
+public type UnitVectorLookahead = unit {
+    length: uint64;
+    inner: Inner[];
+    end_: b"BB";
+};
+
+public type Regex = unit {
+    length: uint64;
+    data: /A*/;
+    end_: b"BB";
+};

spicy/runtime/src/benchmarks/parsing.cc

@@ -0,0 +1,74 @@
+// Copyright (c) 2020-now by the Zeek Project. See LICENSE for details.
+
+#include <benchmark/benchmark.h>
+
+#include <hilti/rt/init.h>
+#include <hilti/rt/types/reference.h>
+#include <hilti/rt/types/stream.h>
+
+#include <spicy/rt/init.h>
+#include <spicy/rt/parsed-unit.h>
+#include <spicy/rt/parser.h>
+
+static std::string big_endian(std::uint64_t number) {
+    char buffer[8];
+    for ( int i = 0; i < 8; ++i ) {
+        buffer[i] = static_cast<char>((number >> (56 - 8 * i)) & 0xFF);
+    }
+    return std::string(buffer, sizeof(buffer));
+}
+
+static std::string make_input(std::uint64_t input_size) {
+    std::string number = big_endian(input_size);
+    std::string repeated(input_size, 'A');
+    return number + repeated + 'B' + 'B';
+}
+
+template<class... Args>
+static void benchmark_parser(benchmark::State& state, Args&&... args) {
+    auto args_tuple = std::make_tuple(std::move(args)...);
+    auto parser_name = std::get<0>(args_tuple);
+
+    hilti::rt::init();
+    spicy::rt::init();
+
+    const spicy::rt::Parser* parser = nullptr;
+    for ( auto* p : spicy::rt::parsers() ) {
+        if ( p->name == parser_name ) {
+            parser = p;
+            break;
+        }
+    }
+
+    assert(parser);
+
+    for ( auto _ : state ) {
+        (void)_;
+        state.PauseTiming();
+        auto in = make_input(state.range(0));
+        auto stream = hilti::rt::reference::make_value<hilti::rt::Stream>(in);
+        stream->freeze();
+        state.ResumeTiming();
+        parser->parse1(stream, {}, {});
+    }
+
+    hilti::rt::done();
+}
+
+static const int64_t min_input = 100;
+static const int64_t max_input = 100000;
+static const int64_t mult = 10;
+
+BENCHMARK_CAPTURE(benchmark_parser, Benchmark::UnitVectorSize, std::string("Benchmark::UnitVectorSize"))
+    ->RangeMultiplier(mult)
+    ->Range(min_input, max_input);
+
+BENCHMARK_CAPTURE(benchmark_parser, Benchmark::UnitVectorLookahead, std::string("Benchmark::UnitVectorLookahead"))
+    ->RangeMultiplier(mult)
+    ->Range(min_input, max_input);
+
+BENCHMARK_CAPTURE(benchmark_parser, Benchmark::Regex, std::string("Benchmark::Regex"))
+    ->RangeMultiplier(mult)
+    ->Range(min_input, max_input);
+
+BENCHMARK_MAIN();