Merge pull request #28 from simdjson/adding_twitter_bench

Adding twitter bench

Author: FranciscoThiesen

CMakeLists.txt

@@ -1,16 +1,19 @@
 cmake_minimum_required(VERSION 3.10)
 set(CMAKE_C_COMPILER clang)
 set(CMAKE_CXX_COMPILER clang++)
-
+add_compile_options(-Wall -Wextra -freflection -stdlib=libc++ -std=c++26)
 project(experimental_json_builder
     VERSION 0.0.1
     DESCRIPTION "Serializing gigabytes of JSON per second"
     HOMEPAGE_URL "https://simdjson.org/"
     LANGUAGES CXX
 )
-
-set(CMAKE_CXX_STANDARD 23)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
+if (NOT CMAKE_BUILD_TYPE)
+  message(STATUS "No build type selected, default to Release")
+  set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
+endif()
+#set(CMAKE_CXX_STANDARD 23)
+#set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 include(cmake/CPM.cmake)
 # include simdjson
@@ -19,6 +22,7 @@ CPMAddPackage("gh:nlohmann/json@3.10.5")
 
 # Optionally, specify the C++ compiler directly (here we use clang++)
 add_subdirectory(src)
+add_subdirectory(examples)
 add_subdirectory(benchmarks/src)
 
 enable_testing()

README.md

@@ -36,7 +36,7 @@ namespace ns {
 Or use one of the Macros described
 [here](https://github.com/nlohmann/json?tab=readme-ov-file#simplify-your-life-with-macros) in your class/struct.
 
-By leveraging reflection, we can support for something as simple as:
+By leveraging compile-time reflection, we can support for something as simple as:
 
 ```c++
 int main() {
@@ -49,6 +49,10 @@ int main() {
 
 With ~200 lines of code (as you can see in the [toy_builder.cpp](prototype_playground/toy_builder.cpp)).
 
+As of now, we were able to implement this with ~1k lines of code (and that is including Neon + SSE2 optimizations in [json_escaping.hpp](src/json_escaping.hpp)).
+
+The benchmark results show that our serialization speed can be 20/30x faster than [nlohmann](https://github.com/nlohmann/json).
+
 ## Current status
 There are 2 versions of compiler that aim to support the C++ 26 reflection paper.
 
@@ -214,6 +218,11 @@ cmake --build build
 ./build/benchmarks/src/SerializationBenchmark
 ```
 
+4. Run the (twitter) benchmark.
+```bash
+./build/benchmarks/src/SerializationTwitterBenchmark
+```
+
 ### Running tests
 
 ```bash

benchmarks/src/CMakeLists.txt

@@ -1,26 +1,65 @@
-cmake_minimum_required(VERSION 3.10) # Set the minimum required version of CMake
+cmake_minimum_required(VERSION 3.10)
+
+project(SerializatonTwitterBenchmark) # Name your project
 
-project(SerializationBenchmark) # Name your project
-if (NOT CMAKE_BUILD_TYPE)
-  message(STATUS "No build type selected, default to Release")
-  set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
-endif()
 # Set C++ standard to C++17 or higher if needed
-set(CMAKE_CXX_STANDARD 23)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
+#set(CMAKE_CXX_STANDARD 23)
+#set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 # Optionally, specify the C++ compiler directly (here we use clang++)
 set(CMAKE_C_COMPILER clang)
 set(CMAKE_CXX_COMPILER clang++)
 
+
+option(SIMDJSON_SANITIZE_MEMORY "Sanitize memory" OFF)
+
+if(SIMDJSON_SANITIZE_MEMORY)
+  message(STATUS "Setting the memory sanitizer.")
+  add_compile_options(
+      -fsanitize=memory -fno-sanitize-recover=all
+  )
+  link_libraries(
+      -fsanitize=memory -fno-sanitize-recover=all
+  )
+endif()
+
+if(NOT CMAKE_BUILD_TYPE)
+  if(SIMDJSON_SANITIZE OR SIMDJSON_SANITIZE_UNDEFINED)
+    message(STATUS "No build type selected and you have enabled the sanitizer, \
+default to Debug. Consider setting CMAKE_BUILD_TYPE.")
+    message(STATUS "Setting debug optimization flag to -O1 to help sanitizer.")
+    set(CMAKE_CXX_FLAGS_DEBUG "-O1" CACHE STRING "" FORCE)
+    set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build." FORCE)
+  else()
+    message(STATUS "No build type selected, default to Release")
+    set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
+  endif()
+endif()
+
+
+# if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+#   set(CMAKE_C_FLAGS_DEBUG "-g -fsanitize=address,undefined -fno-omit-frame-pointer")
+#  set(CMAKE_CXX_FLAGS_DEBUG "-g -fsanitize=address,undefined -fno-omit-frame-pointer")
+# else()
+#   set(CMAKE_C_FLAGS_RELEASE "-O2 -fsanitize=address,undefined")
+#  set(CMAKE_CXX_FLAGS_RELEASE "-O2 -fsanitize=address,undefined")
+#  set(CMAKE_C_FLAGS_RELWITHDEBINFO "-O2 -g -fsanitize=address,undefined")
+#  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g -fsanitize=address,undefined")
+#endif()
+
 # Include directories
 include_directories(${CMAKE_SOURCE_DIR})
 
-# Add executable target
+# Add executable targets
 add_executable(SerializationBenchmark benchmark_serialization.cpp)
+add_executable(SerializationTwitterBenchmark benchmark_serialization_twitter.cpp)
 
 target_compile_options(SerializationBenchmark PRIVATE -freflection -stdlib=libc++ -std=c++26)
-# If you have any libraries to link (e.g., if your project grows and you decide to compile some parts into a library),
-# you would specify them here with target_link_libraries(MyLibraryExample mylib)
+target_compile_options(SerializationTwitterBenchmark PRIVATE -freflection -stdlib=libc++ -std=c++26)
+
+
+# Link sanitizers and libraries
+target_link_libraries(SerializationTwitterBenchmark PRIVATE nlohmann_json::nlohmann_json simdjson::simdjson)
+target_link_libraries(SerializationBenchmark PRIVATE simdjson-serial nlohmann_json::nlohmann_json simdjson::simdjson)
 
-target_link_libraries(SerializationBenchmark PRIVATE simdjson-serial nlohmann_json::nlohmann_json simdjson::simdjson)
+target_compile_definitions(SerializationTwitterBenchmark PRIVATE JSON_FILE="${PROJECT_SOURCE_DIR}/data/twitter.json")

benchmarks/src/apple_arm_events.h

@@ -356,17 +356,17 @@ static u64 (*kperf_ticks_to_ns)(u64 ticks);
 static u64 (*kperf_tick_frequency)(void);
 
 /// Get lightweight PET mode (not in kperf.framework).
-static int kperf_lightweight_pet_get(u32 *enabled) {
+/*static int kperf_lightweight_pet_get(u32 *enabled) {
   if (!enabled)
     return -1;
   usize size = 4;
   return sysctlbyname("kperf.lightweight_pet", enabled, &size, NULL, 0);
-}
+}*/
 
 /// Set lightweight PET mode (not in kperf.framework).
-static int kperf_lightweight_pet_set(u32 enabled) {
+/*static int kperf_lightweight_pet_set(u32 enabled) {
   return sysctlbyname("kperf.lightweight_pet", NULL, NULL, &enabled, 4);
-}
+}*/
 
 // -----------------------------------------------------------------------------
 // <kperfdata.framework> header (reverse engineered)
@@ -834,57 +834,57 @@ typedef struct {
 
 /// Clean up trace buffers and reset ktrace/kdebug/kperf.
 /// @return 0 on success.
-static int kdebug_reset(void) {
+/*static int kdebug_reset(void) {
   int mib[3] = {CTL_KERN, KERN_KDEBUG, KERN_KDREMOVE};
   return sysctl(mib, 3, NULL, NULL, NULL, 0);
-}
+}*/
 
 /// Disable and reinitialize the trace buffers.
 /// @return 0 on success.
-static int kdebug_reinit(void) {
+/*static int kdebug_reinit(void) {
   int mib[3] = {CTL_KERN, KERN_KDEBUG, KERN_KDSETUP};
   return sysctl(mib, 3, NULL, NULL, NULL, 0);
-}
+}*/
 
 /// Set debug filter.
-static int kdebug_setreg(kd_regtype *kdr) {
+/*static int kdebug_setreg(kd_regtype *kdr) {
   int mib[3] = {CTL_KERN, KERN_KDEBUG, KERN_KDSETREG};
   usize size = sizeof(kd_regtype);
   return sysctl(mib, 3, kdr, &size, NULL, 0);
-}
+}*/
 
 /// Set maximum number of trace entries (kd_buf).
 /// Only allow allocation up to half the available memory (sane_size).
 /// @return 0 on success.
-static int kdebug_trace_setbuf(int nbufs) {
+/*static int kdebug_trace_setbuf(int nbufs) {
   int mib[4] = {CTL_KERN, KERN_KDEBUG, KERN_KDSETBUF, nbufs};
   return sysctl(mib, 4, NULL, NULL, NULL, 0);
-}
+}*/
 
 /// Enable or disable kdebug trace.
 /// Trace buffer must already be initialized.
 /// @return 0 on success.
-static int kdebug_trace_enable(bool enable) {
+/*static int kdebug_trace_enable(bool enable) {
   int mib[4] = {CTL_KERN, KERN_KDEBUG, KERN_KDENABLE, enable};
   return sysctl(mib, 4, NULL, 0, NULL, 0);
-}
+}*/
 
 /// Retrieve trace buffer information from kernel.
 /// @return 0 on success.
-static int kdebug_get_bufinfo(kbufinfo_t *info) {
+/*static int kdebug_get_bufinfo(kbufinfo_t *info) {
   if (!info)
     return -1;
   int mib[3] = {CTL_KERN, KERN_KDEBUG, KERN_KDGETBUF};
   size_t needed = sizeof(kbufinfo_t);
   return sysctl(mib, 3, info, &needed, NULL, 0);
-}
+}*/
 
 /// Retrieve trace buffers from kernel.
 /// @param buf Memory to receive buffer data, array of `kd_buf`.
 /// @param len Length of `buf` in bytes.
 /// @param count Number of trace entries (kd_buf) obtained.
 /// @return 0 on success.
-static int kdebug_trace_read(void *buf, usize len, usize *count) {
+/*static int kdebug_trace_read(void *buf, usize len, usize *count) {
   if (count)
     *count = 0;
   if (!buf || !len)
@@ -899,13 +899,13 @@ static int kdebug_trace_read(void *buf, usize len, usize *count) {
     return ret;
   *count = len;
   return 0;
-}
+}*/
 
 /// Block until there are new buffers filled or `timeout_ms` have passed.
 /// @param timeout_ms timeout milliseconds, 0 means wait forever.
 /// @param suc set true if new buffers filled.
 /// @return 0 on success.
-static int kdebug_wait(usize timeout_ms, bool *suc) {
+/*static int kdebug_wait(usize timeout_ms, bool *suc) {
   if (timeout_ms == 0)
     return -1;
   int mib[3] = {CTL_KERN, KERN_KDEBUG, KERN_KDBUFWAIT};
@@ -914,7 +914,7 @@ static int kdebug_wait(usize timeout_ms, bool *suc) {
   if (suc)
     *suc = !!val;
   return ret;
-}
+}*/
 
 // -----------------------------------------------------------------------------
 // Demo